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

       1                 : //
       2                 : // Automatically generated by ipdlc.
       3                 : // Edit at your own risk
       4                 : //
       5                 : 
       6                 : #ifndef PStorage_h
       7                 : #define PStorage_h
       8                 : 
       9                 : #include "mozilla/Attributes.h"
      10                 : #include "base/basictypes.h"
      11                 : #include "prtime.h"
      12                 : #include "nscore.h"
      13                 : #include "IPCMessageStart.h"
      14                 : #include "IPC/IPCMessageUtils.h"
      15                 : #include "nsAutoPtr.h"
      16                 : #include "nsStringGlue.h"
      17                 : #include "nsTArray.h"
      18                 : #include "nsIFile.h"
      19                 : #include "mozilla/ipc/ProtocolUtils.h"
      20                 : 
      21                 : 
      22                 : //-----------------------------------------------------------------------------
      23                 : // Declaration of the IPDL type |struct ItemData|
      24                 : //
      25                 : namespace mozilla {
      26                 : namespace dom {
      27                 : class ItemData MOZ_FINAL
      28                 : {
      29                 : private:
      30                 : 
      31                 : public:
      32                 :     ItemData();
      33                 : 
      34               0 :     ItemData(
      35                 :             const nsString& _value,
      36                 :             const bool& _secure)
      37               0 :     {
      38               0 :         Init();
      39               0 :         Assign(_value, _secure);
      40               0 :     }
      41                 : 
      42               0 :     ItemData(const ItemData& _o)
      43               0 :     {
      44               0 :         Init();
      45               0 :         Assign((_o).value(), (_o).secure());
      46               0 :     }
      47                 : 
      48                 :     ~ItemData();
      49                 : 
      50                 :     void
      51               0 :     operator=(const ItemData& _o)
      52                 :     {
      53               0 :         Assign((_o).value(), (_o).secure());
      54               0 :     }
      55                 : 
      56                 :     bool
      57                 :     operator==(const ItemData& _o) const;
      58                 : 
      59                 :     nsString&
      60               0 :     value()
      61                 :     {
      62               0 :         return value_;
      63                 :     }
      64                 :     const nsString&
      65               0 :     value() const
      66                 :     {
      67               0 :         return value_;
      68                 :     }
      69                 : 
      70                 :     bool&
      71               0 :     secure()
      72                 :     {
      73               0 :         return secure_;
      74                 :     }
      75                 :     const bool&
      76               0 :     secure() const
      77                 :     {
      78               0 :         return secure_;
      79                 :     }
      80                 : 
      81                 : private:
      82                 :     void
      83                 :     Init();
      84                 : 
      85                 :     void
      86                 :     Assign(
      87                 :             const nsString& _value,
      88                 :             const bool& _secure);
      89                 : 
      90                 :     nsString value_;
      91                 :     bool secure_;
      92                 : };
      93                 : } // namespace dom
      94                 : } // namespace mozilla
      95                 : 
      96                 : namespace mozilla {
      97                 : namespace dom {
      98                 : class ItemData;
      99                 : } // namespace dom
     100                 : } // namespace mozilla
     101                 : 
     102                 : //-----------------------------------------------------------------------------
     103                 : // Declaration of the IPDL type |union StorageItem|
     104                 : //
     105                 : namespace mozilla {
     106                 : namespace dom {
     107                 : class StorageItem MOZ_FINAL
     108                 : {
     109                 : public:
     110                 :     enum Type {
     111                 :         T__None,
     112                 :         Tnull_t = 1,
     113                 :         TItemData,
     114                 :         T__Last = TItemData
     115                 :     };
     116                 : 
     117                 : private:
     118                 :     typedef mozilla::null_t null_t;
     119                 :     typedef mozilla::dom::ItemData ItemData;
     120                 :     typedef null_t null_t__tdef;
     121                 :     typedef ItemData ItemData__tdef;
     122                 : 
     123                 :     union Value {
     124                 :         char Vnull_t[sizeof(null_t)];
     125                 :         char VItemData[sizeof(ItemData)];
     126                 :     };
     127                 : 
     128                 :     null_t*
     129               0 :     ptr_null_t()
     130                 :     {
     131               0 :         return reinterpret_cast<null_t*>((&((mValue).Vnull_t)));
     132                 :     }
     133                 :     const null_t* const
     134               0 :     constptr_null_t() const
     135                 :     {
     136               0 :         return reinterpret_cast<const null_t* const>((&((mValue).Vnull_t)));
     137                 :     }
     138                 :     ItemData*
     139               0 :     ptr_ItemData()
     140                 :     {
     141               0 :         return reinterpret_cast<ItemData*>((&((mValue).VItemData)));
     142                 :     }
     143                 :     const ItemData* const
     144               0 :     constptr_ItemData() const
     145                 :     {
     146               0 :         return reinterpret_cast<const ItemData* const>((&((mValue).VItemData)));
     147                 :     }
     148                 : 
     149                 :     bool
     150                 :     MaybeDestroy(Type aNewType);
     151                 : 
     152                 :     void
     153               0 :     AssertSanity() const
     154                 :     {
     155               0 :         NS_ABORT_IF_FALSE((T__None) <= (mType), "invalid type tag");
     156               0 :         NS_ABORT_IF_FALSE((mType) <= (T__Last), "invalid type tag");
     157               0 :     }
     158                 :     void
     159               0 :     AssertSanity(Type aType) const
     160                 :     {
     161               0 :         AssertSanity();
     162               0 :         NS_ABORT_IF_FALSE((mType) == (aType), "unexpected type tag");
     163               0 :     }
     164                 : 
     165                 : public:
     166               0 :     StorageItem() :
     167               0 :         mType(T__None)
     168                 :     {
     169               0 :     }
     170                 : 
     171                 :     StorageItem(const null_t& aOther);
     172                 : 
     173                 :     StorageItem(const ItemData& aOther);
     174                 : 
     175                 :     StorageItem(const StorageItem& aOther);
     176                 : 
     177                 :     ~StorageItem();
     178                 : 
     179                 :     Type
     180               0 :     type() const
     181                 :     {
     182               0 :         return mType;
     183                 :     }
     184                 : 
     185                 :     StorageItem&
     186                 :     operator=(const null_t& aRhs);
     187                 : 
     188                 :     StorageItem&
     189                 :     operator=(const ItemData& aRhs);
     190                 : 
     191                 :     StorageItem&
     192                 :     operator=(const StorageItem& aRhs);
     193                 : 
     194                 :     bool
     195                 :     operator==(const null_t& aRhs) const;
     196                 : 
     197                 :     bool
     198                 :     operator==(const ItemData& aRhs) const;
     199                 : 
     200                 :     bool
     201                 :     operator==(const StorageItem& aRhs) const;
     202                 : 
     203                 :     null_t&
     204               0 :     get_null_t()
     205                 :     {
     206               0 :         AssertSanity(Tnull_t);
     207               0 :         return (*(ptr_null_t()));
     208                 :     }
     209                 :     const null_t&
     210               0 :     get_null_t() const
     211                 :     {
     212               0 :         AssertSanity(Tnull_t);
     213               0 :         return (*(constptr_null_t()));
     214                 :     }
     215                 :     operator null_t&()
     216                 :     {
     217                 :         return get_null_t();
     218                 :     }
     219                 :     operator const null_t&() const
     220                 :     {
     221                 :         return get_null_t();
     222                 :     }
     223                 : 
     224                 :     ItemData&
     225               0 :     get_ItemData()
     226                 :     {
     227               0 :         AssertSanity(TItemData);
     228               0 :         return (*(ptr_ItemData()));
     229                 :     }
     230                 :     const ItemData&
     231               0 :     get_ItemData() const
     232                 :     {
     233               0 :         AssertSanity(TItemData);
     234               0 :         return (*(constptr_ItemData()));
     235                 :     }
     236                 :     operator ItemData&()
     237                 :     {
     238                 :         return get_ItemData();
     239                 :     }
     240                 :     operator const ItemData&() const
     241                 :     {
     242                 :         return get_ItemData();
     243                 :     }
     244                 : 
     245                 : private:
     246                 :     Value mValue;
     247                 :     Type mType;
     248                 : };
     249                 : } // namespace dom
     250                 : } // namespace mozilla
     251                 : 
     252                 : //-----------------------------------------------------------------------------
     253                 : // Code common to PStorageChild and PStorageParent
     254                 : //
     255                 : namespace mozilla {
     256                 : namespace dom {
     257                 : namespace PStorage {
     258                 : 
     259                 : enum State {
     260                 :     __Dead,
     261                 :     __Null,
     262                 :     __Error,
     263                 :     __Start = __Null
     264                 : };
     265                 : 
     266                 : enum MessageType {
     267                 :     PStorageStart = PStorageMsgStart << 16,
     268                 :     PStoragePreStart = (PStorageMsgStart << 16) - 1,
     269                 :     Msg___delete____ID,
     270                 :     Reply___delete____ID,
     271                 :     Msg_Init__ID,
     272                 :     Msg_GetKeys__ID,
     273                 :     Reply_GetKeys__ID,
     274                 :     Msg_GetLength__ID,
     275                 :     Reply_GetLength__ID,
     276                 :     Msg_GetKey__ID,
     277                 :     Reply_GetKey__ID,
     278                 :     Msg_GetValue__ID,
     279                 :     Reply_GetValue__ID,
     280                 :     Msg_SetValue__ID,
     281                 :     Reply_SetValue__ID,
     282                 :     Msg_RemoveValue__ID,
     283                 :     Reply_RemoveValue__ID,
     284                 :     Msg_Clear__ID,
     285                 :     Reply_Clear__ID,
     286                 :     Msg_GetDBValue__ID,
     287                 :     Reply_GetDBValue__ID,
     288                 :     Msg_SetDBValue__ID,
     289                 :     Reply_SetDBValue__ID,
     290                 :     Msg_SetSecure__ID,
     291                 :     Reply_SetSecure__ID,
     292                 :     PStorageEnd
     293                 : };
     294                 : 
     295                 : bool
     296                 : Transition(
     297                 :         State from,
     298                 :         mozilla::ipc::Trigger trigger,
     299                 :         State* next);
     300                 : 
     301                 : class Msg___delete__ :
     302                 :     public IPC::Message
     303               0 : {
     304                 : private:
     305                 :     typedef mozilla::ipc::ActorHandle ActorHandle;
     306                 :     typedef mozilla::dom::ItemData ItemData;
     307                 :     typedef mozilla::dom::StorageItem StorageItem;
     308                 :     typedef mozilla::ipc::Shmem Shmem;
     309                 :     typedef mozilla::null_t null_t;
     310                 : 
     311                 : public:
     312                 :     enum {
     313                 :         ID = Msg___delete____ID
     314                 :     };
     315               0 :     Msg___delete__() :
     316               0 :         IPC::Message(MSG_ROUTING_NONE, ID, PRIORITY_NORMAL, "PStorage::Msg___delete__")
     317                 :     {
     318               0 :     }
     319                 : 
     320                 :     void
     321               0 :     Log(
     322                 :             const std::string& __pfx,
     323                 :             FILE* __outf) const
     324                 :     {
     325               0 :         std::string __logmsg;
     326               0 :         StringAppendF((&(__logmsg)), "[time:%" PRId64 "]", PR_Now());
     327               0 :         (__logmsg).append(__pfx);
     328               0 :         (__logmsg).append("Msg___delete__(");
     329                 : 
     330               0 :         (__logmsg).append("[TODO])\n");
     331               0 :         fputs((__logmsg).c_str(), __outf);
     332               0 :     }
     333                 : };
     334                 : 
     335                 : class Reply___delete__ :
     336                 :     public IPC::Message
     337                 : {
     338                 : private:
     339                 :     typedef mozilla::ipc::ActorHandle ActorHandle;
     340                 :     typedef mozilla::dom::ItemData ItemData;
     341                 :     typedef mozilla::dom::StorageItem StorageItem;
     342                 :     typedef mozilla::ipc::Shmem Shmem;
     343                 :     typedef mozilla::null_t null_t;
     344                 : 
     345                 : public:
     346                 :     enum {
     347                 :         ID = Reply___delete____ID
     348                 :     };
     349                 :     Reply___delete__() :
     350                 :         IPC::Message(MSG_ROUTING_NONE, ID, PRIORITY_NORMAL, "PStorage::Reply___delete__")
     351                 :     {
     352                 :     }
     353                 : 
     354                 :     void
     355                 :     Log(
     356                 :             const std::string& __pfx,
     357                 :             FILE* __outf) const
     358                 :     {
     359                 :         std::string __logmsg;
     360                 :         StringAppendF((&(__logmsg)), "[time:%" PRId64 "]", PR_Now());
     361                 :         (__logmsg).append(__pfx);
     362                 :         (__logmsg).append("Reply___delete__(");
     363                 : 
     364                 :         (__logmsg).append("[TODO])\n");
     365                 :         fputs((__logmsg).c_str(), __outf);
     366                 :     }
     367                 : };
     368                 : 
     369                 : class Msg_Init :
     370                 :     public IPC::Message
     371               0 : {
     372                 : private:
     373                 :     typedef mozilla::ipc::ActorHandle ActorHandle;
     374                 :     typedef mozilla::dom::ItemData ItemData;
     375                 :     typedef mozilla::dom::StorageItem StorageItem;
     376                 :     typedef mozilla::ipc::Shmem Shmem;
     377                 :     typedef mozilla::null_t null_t;
     378                 : 
     379                 : public:
     380                 :     enum {
     381                 :         ID = Msg_Init__ID
     382                 :     };
     383               0 :     Msg_Init() :
     384               0 :         IPC::Message(MSG_ROUTING_NONE, ID, PRIORITY_NORMAL, "PStorage::Msg_Init")
     385                 :     {
     386               0 :     }
     387                 : 
     388                 :     void
     389               0 :     Log(
     390                 :             const std::string& __pfx,
     391                 :             FILE* __outf) const
     392                 :     {
     393               0 :         std::string __logmsg;
     394               0 :         StringAppendF((&(__logmsg)), "[time:%" PRId64 "]", PR_Now());
     395               0 :         (__logmsg).append(__pfx);
     396               0 :         (__logmsg).append("Msg_Init(");
     397                 : 
     398               0 :         (__logmsg).append("[TODO])\n");
     399               0 :         fputs((__logmsg).c_str(), __outf);
     400               0 :     }
     401                 : };
     402                 : 
     403                 : class Msg_GetKeys :
     404                 :     public IPC::Message
     405               0 : {
     406                 : private:
     407                 :     typedef mozilla::ipc::ActorHandle ActorHandle;
     408                 :     typedef mozilla::dom::ItemData ItemData;
     409                 :     typedef mozilla::dom::StorageItem StorageItem;
     410                 :     typedef mozilla::ipc::Shmem Shmem;
     411                 :     typedef mozilla::null_t null_t;
     412                 : 
     413                 : public:
     414                 :     enum {
     415                 :         ID = Msg_GetKeys__ID
     416                 :     };
     417               0 :     Msg_GetKeys() :
     418               0 :         IPC::Message(MSG_ROUTING_NONE, ID, PRIORITY_NORMAL, "PStorage::Msg_GetKeys")
     419                 :     {
     420               0 :     }
     421                 : 
     422                 :     void
     423               0 :     Log(
     424                 :             const std::string& __pfx,
     425                 :             FILE* __outf) const
     426                 :     {
     427               0 :         std::string __logmsg;
     428               0 :         StringAppendF((&(__logmsg)), "[time:%" PRId64 "]", PR_Now());
     429               0 :         (__logmsg).append(__pfx);
     430               0 :         (__logmsg).append("Msg_GetKeys(");
     431                 : 
     432               0 :         (__logmsg).append("[TODO])\n");
     433               0 :         fputs((__logmsg).c_str(), __outf);
     434               0 :     }
     435                 : };
     436                 : 
     437                 : class Reply_GetKeys :
     438                 :     public IPC::Message
     439               0 : {
     440                 : private:
     441                 :     typedef mozilla::ipc::ActorHandle ActorHandle;
     442                 :     typedef mozilla::dom::ItemData ItemData;
     443                 :     typedef mozilla::dom::StorageItem StorageItem;
     444                 :     typedef mozilla::ipc::Shmem Shmem;
     445                 :     typedef mozilla::null_t null_t;
     446                 : 
     447                 : public:
     448                 :     enum {
     449                 :         ID = Reply_GetKeys__ID
     450                 :     };
     451               0 :     Reply_GetKeys() :
     452               0 :         IPC::Message(MSG_ROUTING_NONE, ID, PRIORITY_NORMAL, "PStorage::Reply_GetKeys")
     453                 :     {
     454               0 :     }
     455                 : 
     456                 :     void
     457               0 :     Log(
     458                 :             const std::string& __pfx,
     459                 :             FILE* __outf) const
     460                 :     {
     461               0 :         std::string __logmsg;
     462               0 :         StringAppendF((&(__logmsg)), "[time:%" PRId64 "]", PR_Now());
     463               0 :         (__logmsg).append(__pfx);
     464               0 :         (__logmsg).append("Reply_GetKeys(");
     465                 : 
     466               0 :         (__logmsg).append("[TODO])\n");
     467               0 :         fputs((__logmsg).c_str(), __outf);
     468               0 :     }
     469                 : };
     470                 : 
     471                 : class Msg_GetLength :
     472                 :     public IPC::Message
     473               0 : {
     474                 : private:
     475                 :     typedef mozilla::ipc::ActorHandle ActorHandle;
     476                 :     typedef mozilla::dom::ItemData ItemData;
     477                 :     typedef mozilla::dom::StorageItem StorageItem;
     478                 :     typedef mozilla::ipc::Shmem Shmem;
     479                 :     typedef mozilla::null_t null_t;
     480                 : 
     481                 : public:
     482                 :     enum {
     483                 :         ID = Msg_GetLength__ID
     484                 :     };
     485               0 :     Msg_GetLength() :
     486               0 :         IPC::Message(MSG_ROUTING_NONE, ID, PRIORITY_NORMAL, "PStorage::Msg_GetLength")
     487                 :     {
     488               0 :     }
     489                 : 
     490                 :     void
     491               0 :     Log(
     492                 :             const std::string& __pfx,
     493                 :             FILE* __outf) const
     494                 :     {
     495               0 :         std::string __logmsg;
     496               0 :         StringAppendF((&(__logmsg)), "[time:%" PRId64 "]", PR_Now());
     497               0 :         (__logmsg).append(__pfx);
     498               0 :         (__logmsg).append("Msg_GetLength(");
     499                 : 
     500               0 :         (__logmsg).append("[TODO])\n");
     501               0 :         fputs((__logmsg).c_str(), __outf);
     502               0 :     }
     503                 : };
     504                 : 
     505                 : class Reply_GetLength :
     506                 :     public IPC::Message
     507               0 : {
     508                 : private:
     509                 :     typedef mozilla::ipc::ActorHandle ActorHandle;
     510                 :     typedef mozilla::dom::ItemData ItemData;
     511                 :     typedef mozilla::dom::StorageItem StorageItem;
     512                 :     typedef mozilla::ipc::Shmem Shmem;
     513                 :     typedef mozilla::null_t null_t;
     514                 : 
     515                 : public:
     516                 :     enum {
     517                 :         ID = Reply_GetLength__ID
     518                 :     };
     519               0 :     Reply_GetLength() :
     520               0 :         IPC::Message(MSG_ROUTING_NONE, ID, PRIORITY_NORMAL, "PStorage::Reply_GetLength")
     521                 :     {
     522               0 :     }
     523                 : 
     524                 :     void
     525               0 :     Log(
     526                 :             const std::string& __pfx,
     527                 :             FILE* __outf) const
     528                 :     {
     529               0 :         std::string __logmsg;
     530               0 :         StringAppendF((&(__logmsg)), "[time:%" PRId64 "]", PR_Now());
     531               0 :         (__logmsg).append(__pfx);
     532               0 :         (__logmsg).append("Reply_GetLength(");
     533                 : 
     534               0 :         (__logmsg).append("[TODO])\n");
     535               0 :         fputs((__logmsg).c_str(), __outf);
     536               0 :     }
     537                 : };
     538                 : 
     539                 : class Msg_GetKey :
     540                 :     public IPC::Message
     541               0 : {
     542                 : private:
     543                 :     typedef mozilla::ipc::ActorHandle ActorHandle;
     544                 :     typedef mozilla::dom::ItemData ItemData;
     545                 :     typedef mozilla::dom::StorageItem StorageItem;
     546                 :     typedef mozilla::ipc::Shmem Shmem;
     547                 :     typedef mozilla::null_t null_t;
     548                 : 
     549                 : public:
     550                 :     enum {
     551                 :         ID = Msg_GetKey__ID
     552                 :     };
     553               0 :     Msg_GetKey() :
     554               0 :         IPC::Message(MSG_ROUTING_NONE, ID, PRIORITY_NORMAL, "PStorage::Msg_GetKey")
     555                 :     {
     556               0 :     }
     557                 : 
     558                 :     void
     559               0 :     Log(
     560                 :             const std::string& __pfx,
     561                 :             FILE* __outf) const
     562                 :     {
     563               0 :         std::string __logmsg;
     564               0 :         StringAppendF((&(__logmsg)), "[time:%" PRId64 "]", PR_Now());
     565               0 :         (__logmsg).append(__pfx);
     566               0 :         (__logmsg).append("Msg_GetKey(");
     567                 : 
     568               0 :         (__logmsg).append("[TODO])\n");
     569               0 :         fputs((__logmsg).c_str(), __outf);
     570               0 :     }
     571                 : };
     572                 : 
     573                 : class Reply_GetKey :
     574                 :     public IPC::Message
     575               0 : {
     576                 : private:
     577                 :     typedef mozilla::ipc::ActorHandle ActorHandle;
     578                 :     typedef mozilla::dom::ItemData ItemData;
     579                 :     typedef mozilla::dom::StorageItem StorageItem;
     580                 :     typedef mozilla::ipc::Shmem Shmem;
     581                 :     typedef mozilla::null_t null_t;
     582                 : 
     583                 : public:
     584                 :     enum {
     585                 :         ID = Reply_GetKey__ID
     586                 :     };
     587               0 :     Reply_GetKey() :
     588               0 :         IPC::Message(MSG_ROUTING_NONE, ID, PRIORITY_NORMAL, "PStorage::Reply_GetKey")
     589                 :     {
     590               0 :     }
     591                 : 
     592                 :     void
     593               0 :     Log(
     594                 :             const std::string& __pfx,
     595                 :             FILE* __outf) const
     596                 :     {
     597               0 :         std::string __logmsg;
     598               0 :         StringAppendF((&(__logmsg)), "[time:%" PRId64 "]", PR_Now());
     599               0 :         (__logmsg).append(__pfx);
     600               0 :         (__logmsg).append("Reply_GetKey(");
     601                 : 
     602               0 :         (__logmsg).append("[TODO])\n");
     603               0 :         fputs((__logmsg).c_str(), __outf);
     604               0 :     }
     605                 : };
     606                 : 
     607                 : class Msg_GetValue :
     608                 :     public IPC::Message
     609               0 : {
     610                 : private:
     611                 :     typedef mozilla::ipc::ActorHandle ActorHandle;
     612                 :     typedef mozilla::dom::ItemData ItemData;
     613                 :     typedef mozilla::dom::StorageItem StorageItem;
     614                 :     typedef mozilla::ipc::Shmem Shmem;
     615                 :     typedef mozilla::null_t null_t;
     616                 : 
     617                 : public:
     618                 :     enum {
     619                 :         ID = Msg_GetValue__ID
     620                 :     };
     621               0 :     Msg_GetValue() :
     622               0 :         IPC::Message(MSG_ROUTING_NONE, ID, PRIORITY_NORMAL, "PStorage::Msg_GetValue")
     623                 :     {
     624               0 :     }
     625                 : 
     626                 :     void
     627               0 :     Log(
     628                 :             const std::string& __pfx,
     629                 :             FILE* __outf) const
     630                 :     {
     631               0 :         std::string __logmsg;
     632               0 :         StringAppendF((&(__logmsg)), "[time:%" PRId64 "]", PR_Now());
     633               0 :         (__logmsg).append(__pfx);
     634               0 :         (__logmsg).append("Msg_GetValue(");
     635                 : 
     636               0 :         (__logmsg).append("[TODO])\n");
     637               0 :         fputs((__logmsg).c_str(), __outf);
     638               0 :     }
     639                 : };
     640                 : 
     641                 : class Reply_GetValue :
     642                 :     public IPC::Message
     643               0 : {
     644                 : private:
     645                 :     typedef mozilla::ipc::ActorHandle ActorHandle;
     646                 :     typedef mozilla::dom::ItemData ItemData;
     647                 :     typedef mozilla::dom::StorageItem StorageItem;
     648                 :     typedef mozilla::ipc::Shmem Shmem;
     649                 :     typedef mozilla::null_t null_t;
     650                 : 
     651                 : public:
     652                 :     enum {
     653                 :         ID = Reply_GetValue__ID
     654                 :     };
     655               0 :     Reply_GetValue() :
     656               0 :         IPC::Message(MSG_ROUTING_NONE, ID, PRIORITY_NORMAL, "PStorage::Reply_GetValue")
     657                 :     {
     658               0 :     }
     659                 : 
     660                 :     void
     661               0 :     Log(
     662                 :             const std::string& __pfx,
     663                 :             FILE* __outf) const
     664                 :     {
     665               0 :         std::string __logmsg;
     666               0 :         StringAppendF((&(__logmsg)), "[time:%" PRId64 "]", PR_Now());
     667               0 :         (__logmsg).append(__pfx);
     668               0 :         (__logmsg).append("Reply_GetValue(");
     669                 : 
     670               0 :         (__logmsg).append("[TODO])\n");
     671               0 :         fputs((__logmsg).c_str(), __outf);
     672               0 :     }
     673                 : };
     674                 : 
     675                 : class Msg_SetValue :
     676                 :     public IPC::Message
     677               0 : {
     678                 : private:
     679                 :     typedef mozilla::ipc::ActorHandle ActorHandle;
     680                 :     typedef mozilla::dom::ItemData ItemData;
     681                 :     typedef mozilla::dom::StorageItem StorageItem;
     682                 :     typedef mozilla::ipc::Shmem Shmem;
     683                 :     typedef mozilla::null_t null_t;
     684                 : 
     685                 : public:
     686                 :     enum {
     687                 :         ID = Msg_SetValue__ID
     688                 :     };
     689               0 :     Msg_SetValue() :
     690               0 :         IPC::Message(MSG_ROUTING_NONE, ID, PRIORITY_NORMAL, "PStorage::Msg_SetValue")
     691                 :     {
     692               0 :     }
     693                 : 
     694                 :     void
     695               0 :     Log(
     696                 :             const std::string& __pfx,
     697                 :             FILE* __outf) const
     698                 :     {
     699               0 :         std::string __logmsg;
     700               0 :         StringAppendF((&(__logmsg)), "[time:%" PRId64 "]", PR_Now());
     701               0 :         (__logmsg).append(__pfx);
     702               0 :         (__logmsg).append("Msg_SetValue(");
     703                 : 
     704               0 :         (__logmsg).append("[TODO])\n");
     705               0 :         fputs((__logmsg).c_str(), __outf);
     706               0 :     }
     707                 : };
     708                 : 
     709                 : class Reply_SetValue :
     710                 :     public IPC::Message
     711               0 : {
     712                 : private:
     713                 :     typedef mozilla::ipc::ActorHandle ActorHandle;
     714                 :     typedef mozilla::dom::ItemData ItemData;
     715                 :     typedef mozilla::dom::StorageItem StorageItem;
     716                 :     typedef mozilla::ipc::Shmem Shmem;
     717                 :     typedef mozilla::null_t null_t;
     718                 : 
     719                 : public:
     720                 :     enum {
     721                 :         ID = Reply_SetValue__ID
     722                 :     };
     723               0 :     Reply_SetValue() :
     724               0 :         IPC::Message(MSG_ROUTING_NONE, ID, PRIORITY_NORMAL, "PStorage::Reply_SetValue")
     725                 :     {
     726               0 :     }
     727                 : 
     728                 :     void
     729               0 :     Log(
     730                 :             const std::string& __pfx,
     731                 :             FILE* __outf) const
     732                 :     {
     733               0 :         std::string __logmsg;
     734               0 :         StringAppendF((&(__logmsg)), "[time:%" PRId64 "]", PR_Now());
     735               0 :         (__logmsg).append(__pfx);
     736               0 :         (__logmsg).append("Reply_SetValue(");
     737                 : 
     738               0 :         (__logmsg).append("[TODO])\n");
     739               0 :         fputs((__logmsg).c_str(), __outf);
     740               0 :     }
     741                 : };
     742                 : 
     743                 : class Msg_RemoveValue :
     744                 :     public IPC::Message
     745               0 : {
     746                 : private:
     747                 :     typedef mozilla::ipc::ActorHandle ActorHandle;
     748                 :     typedef mozilla::dom::ItemData ItemData;
     749                 :     typedef mozilla::dom::StorageItem StorageItem;
     750                 :     typedef mozilla::ipc::Shmem Shmem;
     751                 :     typedef mozilla::null_t null_t;
     752                 : 
     753                 : public:
     754                 :     enum {
     755                 :         ID = Msg_RemoveValue__ID
     756                 :     };
     757               0 :     Msg_RemoveValue() :
     758               0 :         IPC::Message(MSG_ROUTING_NONE, ID, PRIORITY_NORMAL, "PStorage::Msg_RemoveValue")
     759                 :     {
     760               0 :     }
     761                 : 
     762                 :     void
     763               0 :     Log(
     764                 :             const std::string& __pfx,
     765                 :             FILE* __outf) const
     766                 :     {
     767               0 :         std::string __logmsg;
     768               0 :         StringAppendF((&(__logmsg)), "[time:%" PRId64 "]", PR_Now());
     769               0 :         (__logmsg).append(__pfx);
     770               0 :         (__logmsg).append("Msg_RemoveValue(");
     771                 : 
     772               0 :         (__logmsg).append("[TODO])\n");
     773               0 :         fputs((__logmsg).c_str(), __outf);
     774               0 :     }
     775                 : };
     776                 : 
     777                 : class Reply_RemoveValue :
     778                 :     public IPC::Message
     779               0 : {
     780                 : private:
     781                 :     typedef mozilla::ipc::ActorHandle ActorHandle;
     782                 :     typedef mozilla::dom::ItemData ItemData;
     783                 :     typedef mozilla::dom::StorageItem StorageItem;
     784                 :     typedef mozilla::ipc::Shmem Shmem;
     785                 :     typedef mozilla::null_t null_t;
     786                 : 
     787                 : public:
     788                 :     enum {
     789                 :         ID = Reply_RemoveValue__ID
     790                 :     };
     791               0 :     Reply_RemoveValue() :
     792               0 :         IPC::Message(MSG_ROUTING_NONE, ID, PRIORITY_NORMAL, "PStorage::Reply_RemoveValue")
     793                 :     {
     794               0 :     }
     795                 : 
     796                 :     void
     797               0 :     Log(
     798                 :             const std::string& __pfx,
     799                 :             FILE* __outf) const
     800                 :     {
     801               0 :         std::string __logmsg;
     802               0 :         StringAppendF((&(__logmsg)), "[time:%" PRId64 "]", PR_Now());
     803               0 :         (__logmsg).append(__pfx);
     804               0 :         (__logmsg).append("Reply_RemoveValue(");
     805                 : 
     806               0 :         (__logmsg).append("[TODO])\n");
     807               0 :         fputs((__logmsg).c_str(), __outf);
     808               0 :     }
     809                 : };
     810                 : 
     811                 : class Msg_Clear :
     812                 :     public IPC::Message
     813               0 : {
     814                 : private:
     815                 :     typedef mozilla::ipc::ActorHandle ActorHandle;
     816                 :     typedef mozilla::dom::ItemData ItemData;
     817                 :     typedef mozilla::dom::StorageItem StorageItem;
     818                 :     typedef mozilla::ipc::Shmem Shmem;
     819                 :     typedef mozilla::null_t null_t;
     820                 : 
     821                 : public:
     822                 :     enum {
     823                 :         ID = Msg_Clear__ID
     824                 :     };
     825               0 :     Msg_Clear() :
     826               0 :         IPC::Message(MSG_ROUTING_NONE, ID, PRIORITY_NORMAL, "PStorage::Msg_Clear")
     827                 :     {
     828               0 :     }
     829                 : 
     830                 :     void
     831               0 :     Log(
     832                 :             const std::string& __pfx,
     833                 :             FILE* __outf) const
     834                 :     {
     835               0 :         std::string __logmsg;
     836               0 :         StringAppendF((&(__logmsg)), "[time:%" PRId64 "]", PR_Now());
     837               0 :         (__logmsg).append(__pfx);
     838               0 :         (__logmsg).append("Msg_Clear(");
     839                 : 
     840               0 :         (__logmsg).append("[TODO])\n");
     841               0 :         fputs((__logmsg).c_str(), __outf);
     842               0 :     }
     843                 : };
     844                 : 
     845                 : class Reply_Clear :
     846                 :     public IPC::Message
     847               0 : {
     848                 : private:
     849                 :     typedef mozilla::ipc::ActorHandle ActorHandle;
     850                 :     typedef mozilla::dom::ItemData ItemData;
     851                 :     typedef mozilla::dom::StorageItem StorageItem;
     852                 :     typedef mozilla::ipc::Shmem Shmem;
     853                 :     typedef mozilla::null_t null_t;
     854                 : 
     855                 : public:
     856                 :     enum {
     857                 :         ID = Reply_Clear__ID
     858                 :     };
     859               0 :     Reply_Clear() :
     860               0 :         IPC::Message(MSG_ROUTING_NONE, ID, PRIORITY_NORMAL, "PStorage::Reply_Clear")
     861                 :     {
     862               0 :     }
     863                 : 
     864                 :     void
     865               0 :     Log(
     866                 :             const std::string& __pfx,
     867                 :             FILE* __outf) const
     868                 :     {
     869               0 :         std::string __logmsg;
     870               0 :         StringAppendF((&(__logmsg)), "[time:%" PRId64 "]", PR_Now());
     871               0 :         (__logmsg).append(__pfx);
     872               0 :         (__logmsg).append("Reply_Clear(");
     873                 : 
     874               0 :         (__logmsg).append("[TODO])\n");
     875               0 :         fputs((__logmsg).c_str(), __outf);
     876               0 :     }
     877                 : };
     878                 : 
     879                 : class Msg_GetDBValue :
     880                 :     public IPC::Message
     881               0 : {
     882                 : private:
     883                 :     typedef mozilla::ipc::ActorHandle ActorHandle;
     884                 :     typedef mozilla::dom::ItemData ItemData;
     885                 :     typedef mozilla::dom::StorageItem StorageItem;
     886                 :     typedef mozilla::ipc::Shmem Shmem;
     887                 :     typedef mozilla::null_t null_t;
     888                 : 
     889                 : public:
     890                 :     enum {
     891                 :         ID = Msg_GetDBValue__ID
     892                 :     };
     893               0 :     Msg_GetDBValue() :
     894               0 :         IPC::Message(MSG_ROUTING_NONE, ID, PRIORITY_NORMAL, "PStorage::Msg_GetDBValue")
     895                 :     {
     896               0 :     }
     897                 : 
     898                 :     void
     899               0 :     Log(
     900                 :             const std::string& __pfx,
     901                 :             FILE* __outf) const
     902                 :     {
     903               0 :         std::string __logmsg;
     904               0 :         StringAppendF((&(__logmsg)), "[time:%" PRId64 "]", PR_Now());
     905               0 :         (__logmsg).append(__pfx);
     906               0 :         (__logmsg).append("Msg_GetDBValue(");
     907                 : 
     908               0 :         (__logmsg).append("[TODO])\n");
     909               0 :         fputs((__logmsg).c_str(), __outf);
     910               0 :     }
     911                 : };
     912                 : 
     913                 : class Reply_GetDBValue :
     914                 :     public IPC::Message
     915               0 : {
     916                 : private:
     917                 :     typedef mozilla::ipc::ActorHandle ActorHandle;
     918                 :     typedef mozilla::dom::ItemData ItemData;
     919                 :     typedef mozilla::dom::StorageItem StorageItem;
     920                 :     typedef mozilla::ipc::Shmem Shmem;
     921                 :     typedef mozilla::null_t null_t;
     922                 : 
     923                 : public:
     924                 :     enum {
     925                 :         ID = Reply_GetDBValue__ID
     926                 :     };
     927               0 :     Reply_GetDBValue() :
     928               0 :         IPC::Message(MSG_ROUTING_NONE, ID, PRIORITY_NORMAL, "PStorage::Reply_GetDBValue")
     929                 :     {
     930               0 :     }
     931                 : 
     932                 :     void
     933               0 :     Log(
     934                 :             const std::string& __pfx,
     935                 :             FILE* __outf) const
     936                 :     {
     937               0 :         std::string __logmsg;
     938               0 :         StringAppendF((&(__logmsg)), "[time:%" PRId64 "]", PR_Now());
     939               0 :         (__logmsg).append(__pfx);
     940               0 :         (__logmsg).append("Reply_GetDBValue(");
     941                 : 
     942               0 :         (__logmsg).append("[TODO])\n");
     943               0 :         fputs((__logmsg).c_str(), __outf);
     944               0 :     }
     945                 : };
     946                 : 
     947                 : class Msg_SetDBValue :
     948                 :     public IPC::Message
     949               0 : {
     950                 : private:
     951                 :     typedef mozilla::ipc::ActorHandle ActorHandle;
     952                 :     typedef mozilla::dom::ItemData ItemData;
     953                 :     typedef mozilla::dom::StorageItem StorageItem;
     954                 :     typedef mozilla::ipc::Shmem Shmem;
     955                 :     typedef mozilla::null_t null_t;
     956                 : 
     957                 : public:
     958                 :     enum {
     959                 :         ID = Msg_SetDBValue__ID
     960                 :     };
     961               0 :     Msg_SetDBValue() :
     962               0 :         IPC::Message(MSG_ROUTING_NONE, ID, PRIORITY_NORMAL, "PStorage::Msg_SetDBValue")
     963                 :     {
     964               0 :     }
     965                 : 
     966                 :     void
     967               0 :     Log(
     968                 :             const std::string& __pfx,
     969                 :             FILE* __outf) const
     970                 :     {
     971               0 :         std::string __logmsg;
     972               0 :         StringAppendF((&(__logmsg)), "[time:%" PRId64 "]", PR_Now());
     973               0 :         (__logmsg).append(__pfx);
     974               0 :         (__logmsg).append("Msg_SetDBValue(");
     975                 : 
     976               0 :         (__logmsg).append("[TODO])\n");
     977               0 :         fputs((__logmsg).c_str(), __outf);
     978               0 :     }
     979                 : };
     980                 : 
     981                 : class Reply_SetDBValue :
     982                 :     public IPC::Message
     983               0 : {
     984                 : private:
     985                 :     typedef mozilla::ipc::ActorHandle ActorHandle;
     986                 :     typedef mozilla::dom::ItemData ItemData;
     987                 :     typedef mozilla::dom::StorageItem StorageItem;
     988                 :     typedef mozilla::ipc::Shmem Shmem;
     989                 :     typedef mozilla::null_t null_t;
     990                 : 
     991                 : public:
     992                 :     enum {
     993                 :         ID = Reply_SetDBValue__ID
     994                 :     };
     995               0 :     Reply_SetDBValue() :
     996               0 :         IPC::Message(MSG_ROUTING_NONE, ID, PRIORITY_NORMAL, "PStorage::Reply_SetDBValue")
     997                 :     {
     998               0 :     }
     999                 : 
    1000                 :     void
    1001               0 :     Log(
    1002                 :             const std::string& __pfx,
    1003                 :             FILE* __outf) const
    1004                 :     {
    1005               0 :         std::string __logmsg;
    1006               0 :         StringAppendF((&(__logmsg)), "[time:%" PRId64 "]", PR_Now());
    1007               0 :         (__logmsg).append(__pfx);
    1008               0 :         (__logmsg).append("Reply_SetDBValue(");
    1009                 : 
    1010               0 :         (__logmsg).append("[TODO])\n");
    1011               0 :         fputs((__logmsg).c_str(), __outf);
    1012               0 :     }
    1013                 : };
    1014                 : 
    1015                 : class Msg_SetSecure :
    1016                 :     public IPC::Message
    1017               0 : {
    1018                 : private:
    1019                 :     typedef mozilla::ipc::ActorHandle ActorHandle;
    1020                 :     typedef mozilla::dom::ItemData ItemData;
    1021                 :     typedef mozilla::dom::StorageItem StorageItem;
    1022                 :     typedef mozilla::ipc::Shmem Shmem;
    1023                 :     typedef mozilla::null_t null_t;
    1024                 : 
    1025                 : public:
    1026                 :     enum {
    1027                 :         ID = Msg_SetSecure__ID
    1028                 :     };
    1029               0 :     Msg_SetSecure() :
    1030               0 :         IPC::Message(MSG_ROUTING_NONE, ID, PRIORITY_NORMAL, "PStorage::Msg_SetSecure")
    1031                 :     {
    1032               0 :     }
    1033                 : 
    1034                 :     void
    1035               0 :     Log(
    1036                 :             const std::string& __pfx,
    1037                 :             FILE* __outf) const
    1038                 :     {
    1039               0 :         std::string __logmsg;
    1040               0 :         StringAppendF((&(__logmsg)), "[time:%" PRId64 "]", PR_Now());
    1041               0 :         (__logmsg).append(__pfx);
    1042               0 :         (__logmsg).append("Msg_SetSecure(");
    1043                 : 
    1044               0 :         (__logmsg).append("[TODO])\n");
    1045               0 :         fputs((__logmsg).c_str(), __outf);
    1046               0 :     }
    1047                 : };
    1048                 : 
    1049                 : class Reply_SetSecure :
    1050                 :     public IPC::Message
    1051               0 : {
    1052                 : private:
    1053                 :     typedef mozilla::ipc::ActorHandle ActorHandle;
    1054                 :     typedef mozilla::dom::ItemData ItemData;
    1055                 :     typedef mozilla::dom::StorageItem StorageItem;
    1056                 :     typedef mozilla::ipc::Shmem Shmem;
    1057                 :     typedef mozilla::null_t null_t;
    1058                 : 
    1059                 : public:
    1060                 :     enum {
    1061                 :         ID = Reply_SetSecure__ID
    1062                 :     };
    1063               0 :     Reply_SetSecure() :
    1064               0 :         IPC::Message(MSG_ROUTING_NONE, ID, PRIORITY_NORMAL, "PStorage::Reply_SetSecure")
    1065                 :     {
    1066               0 :     }
    1067                 : 
    1068                 :     void
    1069               0 :     Log(
    1070                 :             const std::string& __pfx,
    1071                 :             FILE* __outf) const
    1072                 :     {
    1073               0 :         std::string __logmsg;
    1074               0 :         StringAppendF((&(__logmsg)), "[time:%" PRId64 "]", PR_Now());
    1075               0 :         (__logmsg).append(__pfx);
    1076               0 :         (__logmsg).append("Reply_SetSecure(");
    1077                 : 
    1078               0 :         (__logmsg).append("[TODO])\n");
    1079               0 :         fputs((__logmsg).c_str(), __outf);
    1080               0 :     }
    1081                 : };
    1082                 : 
    1083                 : 
    1084                 : 
    1085                 : } // namespace PStorage
    1086                 : } // namespace dom
    1087                 : } // namespace mozilla
    1088                 : 
    1089                 : #endif // ifndef PStorage_h

Generated by: LCOV version 1.7