LCOV - code coverage report
Current view: directory - objdir/ipc/ipdl - PStorageParent.cpp (source / functions) Found Hit Coverage
Test: app.info Lines: 479 0 0.0 %
Date: 2012-06-02 Functions: 40 0 0.0 %

       1                 : //
       2                 : // Automatically generated by ipdlc.
       3                 : // Edit at your own risk
       4                 : //
       5                 : 
       6                 : 
       7                 : #include "mozilla/dom/PStorageParent.h"
       8                 : 
       9                 : #include "mozilla/dom/PContentParent.h"
      10                 : 
      11                 : typedef IPC::Message Message;
      12                 : typedef mozilla::ipc::RPCChannel Channel;
      13                 : typedef mozilla::ipc::RPCChannel::RPCListener ChannelListener;
      14                 : typedef base::ProcessHandle ProcessHandle;
      15                 : typedef mozilla::ipc::AsyncChannel AsyncChannel;
      16                 : typedef mozilla::ipc::SharedMemory SharedMemory;
      17                 : typedef mozilla::ipc::Trigger Trigger;
      18                 : typedef mozilla::ipc::ActorHandle ActorHandle;
      19                 : typedef mozilla::dom::ItemData ItemData;
      20                 : typedef mozilla::dom::StorageItem StorageItem;
      21                 : typedef mozilla::ipc::Shmem Shmem;
      22                 : typedef mozilla::null_t null_t;
      23                 : using mozilla::dom::PContentParent;
      24                 : 
      25                 : namespace mozilla {
      26                 : namespace dom {
      27                 : 
      28                 : 
      29                 : bool
      30               0 : PStorageParent::Recv__delete__()
      31                 : {
      32               0 :     return true;
      33                 : }
      34                 : 
      35                 : void
      36               0 : PStorageParent::ActorDestroy(ActorDestroyReason why)
      37                 : {
      38               0 : }
      39                 : 
      40               0 : PStorageParent::PStorageParent() :
      41                 :     mId(0),
      42               0 :     mState(PStorage::__Dead)
      43                 : {
      44               0 :     MOZ_COUNT_CTOR(PStorageParent);
      45               0 : }
      46                 : 
      47               0 : PStorageParent::~PStorageParent()
      48                 : {
      49               0 :     MOZ_COUNT_DTOR(PStorageParent);
      50               0 : }
      51                 : 
      52                 : PContentParent*
      53               0 : PStorageParent::Manager()
      54                 : {
      55               0 :     return static_cast<PContentParent*>(mManager);
      56                 : }
      57                 : 
      58                 : PStorage::State
      59               0 : PStorageParent::state()
      60                 : {
      61               0 :     return mState;
      62                 : }
      63                 : 
      64                 : int32
      65               0 : PStorageParent::Register(ChannelListener* aRouted)
      66                 : {
      67               0 :     return (mManager)->Register(aRouted);
      68                 : }
      69                 : 
      70                 : int32
      71               0 : PStorageParent::RegisterID(
      72                 :         ChannelListener* aRouted,
      73                 :         int32 aId)
      74                 : {
      75               0 :     return (mManager)->RegisterID(aRouted, aId);
      76                 : }
      77                 : 
      78                 : ChannelListener*
      79               0 : PStorageParent::Lookup(int32 aId)
      80                 : {
      81               0 :     return (mManager)->Lookup(aId);
      82                 : }
      83                 : 
      84                 : void
      85               0 : PStorageParent::Unregister(int32 aId)
      86                 : {
      87               0 :     return (mManager)->Unregister(aId);
      88                 : }
      89                 : 
      90                 : void
      91               0 : PStorageParent::RemoveManagee(
      92                 :         int32 aProtocolId,
      93                 :         ChannelListener* aListener)
      94                 : {
      95               0 :     NS_RUNTIMEABORT("unreached");
      96                 :     return;
      97                 : }
      98                 : 
      99                 : Shmem::SharedMemory*
     100               0 : PStorageParent::CreateSharedMemory(
     101                 :         size_t aSize,
     102                 :         Shmem::SharedMemory::SharedMemoryType type,
     103                 :         bool unsafe,
     104                 :         Shmem::id_t* aId)
     105                 : {
     106               0 :     return (mManager)->CreateSharedMemory(aSize, type, unsafe, aId);
     107                 : }
     108                 : 
     109                 : bool
     110               0 : PStorageParent::AdoptSharedMemory(
     111                 :         Shmem::SharedMemory* segment,
     112                 :         Shmem::id_t* aId)
     113                 : {
     114               0 :     return (mManager)->AdoptSharedMemory(segment, aId);
     115                 : }
     116                 : 
     117                 : Shmem::SharedMemory*
     118               0 : PStorageParent::LookupSharedMemory(Shmem::id_t aId)
     119                 : {
     120               0 :     return (mManager)->LookupSharedMemory(aId);
     121                 : }
     122                 : 
     123                 : bool
     124               0 : PStorageParent::IsTrackingSharedMemory(Shmem::SharedMemory* segment)
     125                 : {
     126               0 :     return (mManager)->IsTrackingSharedMemory(segment);
     127                 : }
     128                 : 
     129                 : bool
     130               0 : PStorageParent::DestroySharedMemory(Shmem& aShmem)
     131                 : {
     132               0 :     return (mManager)->DestroySharedMemory(aShmem);
     133                 : }
     134                 : 
     135                 : ProcessHandle
     136               0 : PStorageParent::OtherProcess() const
     137                 : {
     138               0 :     return (mManager)->OtherProcess();
     139                 : }
     140                 : 
     141                 : AsyncChannel*
     142               0 : PStorageParent::GetIPCChannel()
     143                 : {
     144               0 :     return mChannel;
     145                 : }
     146                 : 
     147                 : PStorageParent::Result
     148               0 : PStorageParent::OnMessageReceived(const Message& __msg)
     149                 : {
     150               0 :     switch ((__msg).type()) {
     151                 :     case PStorage::Msg___delete____ID:
     152                 :         {
     153               0 :             (const_cast<Message&>(__msg)).set_name("PStorage::Msg___delete__");
     154               0 :             if (mozilla::ipc::LoggingEnabled()) {
     155               0 :                 (static_cast<const PStorage::Msg___delete__*>((&(__msg))))->Log("[PStorageParent] Received ", stderr);
     156                 :             }
     157                 : 
     158               0 :             void* __iter = 0;
     159                 :             PStorageParent* actor;
     160                 : 
     161               0 :             if ((!(Read((&(actor)), (&(__msg)), (&(__iter)), false)))) {
     162               0 :                 FatalError("error deserializing (better message TODO)");
     163               0 :                 return MsgValueError;
     164                 :             }
     165               0 :             (__msg).EndRead(__iter);
     166               0 :             if ((!(PStorage::Transition(mState, Trigger(Trigger::Recv, PStorage::Msg___delete____ID), (&(mState)))))) {
     167               0 :                 NS_WARNING("bad state transition!");
     168                 :             }
     169               0 :             if ((!(Recv__delete__()))) {
     170               0 :                 return MsgProcessingError;
     171                 :             }
     172                 : 
     173               0 :             (actor)->DestroySubtree(Deletion);
     174               0 :             (actor)->DeallocSubtree();
     175               0 :             ((actor)->mManager)->RemoveManagee(PStorageMsgStart, actor);
     176                 : 
     177                 : 
     178               0 :             return MsgProcessed;
     179                 :         }
     180                 :     case PStorage::Msg_Init__ID:
     181                 :         {
     182               0 :             (const_cast<Message&>(__msg)).set_name("PStorage::Msg_Init");
     183               0 :             if (mozilla::ipc::LoggingEnabled()) {
     184               0 :                 (static_cast<const PStorage::Msg_Init*>((&(__msg))))->Log("[PStorageParent] Received ", stderr);
     185                 :             }
     186                 : 
     187               0 :             void* __iter = 0;
     188                 :             bool useDB;
     189                 :             bool canUseChromePersist;
     190                 :             bool sessionOnly;
     191               0 :             nsCString domain;
     192               0 :             nsCString scopeDBKey;
     193               0 :             nsCString quotaDomainDBKey;
     194               0 :             nsCString quotaETLDplus1DomainDBKey;
     195                 :             PRUint32 storageType;
     196                 : 
     197               0 :             if ((!(Read((&(useDB)), (&(__msg)), (&(__iter)))))) {
     198               0 :                 FatalError("error deserializing (better message TODO)");
     199               0 :                 return MsgValueError;
     200                 :             }
     201               0 :             if ((!(Read((&(canUseChromePersist)), (&(__msg)), (&(__iter)))))) {
     202               0 :                 FatalError("error deserializing (better message TODO)");
     203               0 :                 return MsgValueError;
     204                 :             }
     205               0 :             if ((!(Read((&(sessionOnly)), (&(__msg)), (&(__iter)))))) {
     206               0 :                 FatalError("error deserializing (better message TODO)");
     207               0 :                 return MsgValueError;
     208                 :             }
     209               0 :             if ((!(Read((&(domain)), (&(__msg)), (&(__iter)))))) {
     210               0 :                 FatalError("error deserializing (better message TODO)");
     211               0 :                 return MsgValueError;
     212                 :             }
     213               0 :             if ((!(Read((&(scopeDBKey)), (&(__msg)), (&(__iter)))))) {
     214               0 :                 FatalError("error deserializing (better message TODO)");
     215               0 :                 return MsgValueError;
     216                 :             }
     217               0 :             if ((!(Read((&(quotaDomainDBKey)), (&(__msg)), (&(__iter)))))) {
     218               0 :                 FatalError("error deserializing (better message TODO)");
     219               0 :                 return MsgValueError;
     220                 :             }
     221               0 :             if ((!(Read((&(quotaETLDplus1DomainDBKey)), (&(__msg)), (&(__iter)))))) {
     222               0 :                 FatalError("error deserializing (better message TODO)");
     223               0 :                 return MsgValueError;
     224                 :             }
     225               0 :             if ((!(Read((&(storageType)), (&(__msg)), (&(__iter)))))) {
     226               0 :                 FatalError("error deserializing (better message TODO)");
     227               0 :                 return MsgValueError;
     228                 :             }
     229               0 :             (__msg).EndRead(__iter);
     230               0 :             if ((!(PStorage::Transition(mState, Trigger(Trigger::Recv, PStorage::Msg_Init__ID), (&(mState)))))) {
     231               0 :                 NS_WARNING("bad state transition!");
     232                 :             }
     233               0 :             if ((!(RecvInit(useDB, canUseChromePersist, sessionOnly, domain, scopeDBKey, quotaDomainDBKey, quotaETLDplus1DomainDBKey, storageType)))) {
     234               0 :                 return MsgProcessingError;
     235                 :             }
     236                 : 
     237               0 :             return MsgProcessed;
     238                 :         }
     239                 :     default:
     240                 :         {
     241               0 :             return MsgNotKnown;
     242                 :         }
     243                 :     }
     244                 : }
     245                 : 
     246                 : PStorageParent::Result
     247               0 : PStorageParent::OnMessageReceived(
     248                 :         const Message& __msg,
     249                 :         Message*& __reply)
     250                 : {
     251               0 :     switch ((__msg).type()) {
     252                 :     case PStorage::Msg_GetKeys__ID:
     253                 :         {
     254               0 :             (const_cast<Message&>(__msg)).set_name("PStorage::Msg_GetKeys");
     255               0 :             if (mozilla::ipc::LoggingEnabled()) {
     256               0 :                 (static_cast<const PStorage::Msg_GetKeys*>((&(__msg))))->Log("[PStorageParent] Received ", stderr);
     257                 :             }
     258                 : 
     259               0 :             void* __iter = 0;
     260                 :             bool callerSecure;
     261                 : 
     262               0 :             if ((!(Read((&(callerSecure)), (&(__msg)), (&(__iter)))))) {
     263               0 :                 FatalError("error deserializing (better message TODO)");
     264               0 :                 return MsgValueError;
     265                 :             }
     266               0 :             (__msg).EndRead(__iter);
     267               0 :             if ((!(PStorage::Transition(mState, Trigger(Trigger::Recv, PStorage::Msg_GetKeys__ID), (&(mState)))))) {
     268               0 :                 NS_WARNING("bad state transition!");
     269                 :             }
     270               0 :             InfallibleTArray<nsString> keys;
     271               0 :             int32 __id = mId;
     272               0 :             if ((!(RecvGetKeys(callerSecure, (&(keys)))))) {
     273               0 :                 return MsgProcessingError;
     274                 :             }
     275                 : 
     276               0 :             __reply = new PStorage::Reply_GetKeys();
     277                 : 
     278               0 :             Write(keys, __reply);
     279               0 :             (__reply)->set_routing_id(__id);
     280               0 :             (__reply)->set_sync();
     281               0 :             (__reply)->set_reply();
     282                 : 
     283               0 :             if (mozilla::ipc::LoggingEnabled()) {
     284               0 :                 (static_cast<const PStorage::Reply_GetKeys*>(__reply))->Log("[PStorageParent] Sending reply ", stderr);
     285                 :             }
     286               0 :             return MsgProcessed;
     287                 :         }
     288                 :     case PStorage::Msg_GetLength__ID:
     289                 :         {
     290               0 :             (const_cast<Message&>(__msg)).set_name("PStorage::Msg_GetLength");
     291               0 :             if (mozilla::ipc::LoggingEnabled()) {
     292               0 :                 (static_cast<const PStorage::Msg_GetLength*>((&(__msg))))->Log("[PStorageParent] Received ", stderr);
     293                 :             }
     294                 : 
     295               0 :             void* __iter = 0;
     296                 :             bool callerSecure;
     297                 :             bool sessionOnly;
     298                 : 
     299               0 :             if ((!(Read((&(callerSecure)), (&(__msg)), (&(__iter)))))) {
     300               0 :                 FatalError("error deserializing (better message TODO)");
     301               0 :                 return MsgValueError;
     302                 :             }
     303               0 :             if ((!(Read((&(sessionOnly)), (&(__msg)), (&(__iter)))))) {
     304               0 :                 FatalError("error deserializing (better message TODO)");
     305               0 :                 return MsgValueError;
     306                 :             }
     307               0 :             (__msg).EndRead(__iter);
     308               0 :             if ((!(PStorage::Transition(mState, Trigger(Trigger::Recv, PStorage::Msg_GetLength__ID), (&(mState)))))) {
     309               0 :                 NS_WARNING("bad state transition!");
     310                 :             }
     311                 :             PRUint32 length;
     312                 :             nsresult rv;
     313               0 :             int32 __id = mId;
     314               0 :             if ((!(RecvGetLength(callerSecure, sessionOnly, (&(length)), (&(rv)))))) {
     315               0 :                 return MsgProcessingError;
     316                 :             }
     317                 : 
     318               0 :             __reply = new PStorage::Reply_GetLength();
     319                 : 
     320               0 :             Write(length, __reply);
     321               0 :             Write(rv, __reply);
     322               0 :             (__reply)->set_routing_id(__id);
     323               0 :             (__reply)->set_sync();
     324               0 :             (__reply)->set_reply();
     325                 : 
     326               0 :             if (mozilla::ipc::LoggingEnabled()) {
     327               0 :                 (static_cast<const PStorage::Reply_GetLength*>(__reply))->Log("[PStorageParent] Sending reply ", stderr);
     328                 :             }
     329               0 :             return MsgProcessed;
     330                 :         }
     331                 :     case PStorage::Msg_GetKey__ID:
     332                 :         {
     333               0 :             (const_cast<Message&>(__msg)).set_name("PStorage::Msg_GetKey");
     334               0 :             if (mozilla::ipc::LoggingEnabled()) {
     335               0 :                 (static_cast<const PStorage::Msg_GetKey*>((&(__msg))))->Log("[PStorageParent] Received ", stderr);
     336                 :             }
     337                 : 
     338               0 :             void* __iter = 0;
     339                 :             bool callerSecure;
     340                 :             bool sessionOnly;
     341                 :             PRUint32 index;
     342                 : 
     343               0 :             if ((!(Read((&(callerSecure)), (&(__msg)), (&(__iter)))))) {
     344               0 :                 FatalError("error deserializing (better message TODO)");
     345               0 :                 return MsgValueError;
     346                 :             }
     347               0 :             if ((!(Read((&(sessionOnly)), (&(__msg)), (&(__iter)))))) {
     348               0 :                 FatalError("error deserializing (better message TODO)");
     349               0 :                 return MsgValueError;
     350                 :             }
     351               0 :             if ((!(Read((&(index)), (&(__msg)), (&(__iter)))))) {
     352               0 :                 FatalError("error deserializing (better message TODO)");
     353               0 :                 return MsgValueError;
     354                 :             }
     355               0 :             (__msg).EndRead(__iter);
     356               0 :             if ((!(PStorage::Transition(mState, Trigger(Trigger::Recv, PStorage::Msg_GetKey__ID), (&(mState)))))) {
     357               0 :                 NS_WARNING("bad state transition!");
     358                 :             }
     359               0 :             nsString key;
     360                 :             nsresult rv;
     361               0 :             int32 __id = mId;
     362               0 :             if ((!(RecvGetKey(callerSecure, sessionOnly, index, (&(key)), (&(rv)))))) {
     363               0 :                 return MsgProcessingError;
     364                 :             }
     365                 : 
     366               0 :             __reply = new PStorage::Reply_GetKey();
     367                 : 
     368               0 :             Write(key, __reply);
     369               0 :             Write(rv, __reply);
     370               0 :             (__reply)->set_routing_id(__id);
     371               0 :             (__reply)->set_sync();
     372               0 :             (__reply)->set_reply();
     373                 : 
     374               0 :             if (mozilla::ipc::LoggingEnabled()) {
     375               0 :                 (static_cast<const PStorage::Reply_GetKey*>(__reply))->Log("[PStorageParent] Sending reply ", stderr);
     376                 :             }
     377               0 :             return MsgProcessed;
     378                 :         }
     379                 :     case PStorage::Msg_GetValue__ID:
     380                 :         {
     381               0 :             (const_cast<Message&>(__msg)).set_name("PStorage::Msg_GetValue");
     382               0 :             if (mozilla::ipc::LoggingEnabled()) {
     383               0 :                 (static_cast<const PStorage::Msg_GetValue*>((&(__msg))))->Log("[PStorageParent] Received ", stderr);
     384                 :             }
     385                 : 
     386               0 :             void* __iter = 0;
     387                 :             bool callerSecure;
     388                 :             bool sessionOnly;
     389               0 :             nsString key;
     390                 : 
     391               0 :             if ((!(Read((&(callerSecure)), (&(__msg)), (&(__iter)))))) {
     392               0 :                 FatalError("error deserializing (better message TODO)");
     393               0 :                 return MsgValueError;
     394                 :             }
     395               0 :             if ((!(Read((&(sessionOnly)), (&(__msg)), (&(__iter)))))) {
     396               0 :                 FatalError("error deserializing (better message TODO)");
     397               0 :                 return MsgValueError;
     398                 :             }
     399               0 :             if ((!(Read((&(key)), (&(__msg)), (&(__iter)))))) {
     400               0 :                 FatalError("error deserializing (better message TODO)");
     401               0 :                 return MsgValueError;
     402                 :             }
     403               0 :             (__msg).EndRead(__iter);
     404               0 :             if ((!(PStorage::Transition(mState, Trigger(Trigger::Recv, PStorage::Msg_GetValue__ID), (&(mState)))))) {
     405               0 :                 NS_WARNING("bad state transition!");
     406                 :             }
     407               0 :             StorageItem item;
     408                 :             nsresult rv;
     409               0 :             int32 __id = mId;
     410               0 :             if ((!(RecvGetValue(callerSecure, sessionOnly, key, (&(item)), (&(rv)))))) {
     411               0 :                 return MsgProcessingError;
     412                 :             }
     413                 : 
     414               0 :             __reply = new PStorage::Reply_GetValue();
     415                 : 
     416               0 :             Write(item, __reply);
     417               0 :             Write(rv, __reply);
     418               0 :             (__reply)->set_routing_id(__id);
     419               0 :             (__reply)->set_sync();
     420               0 :             (__reply)->set_reply();
     421                 : 
     422               0 :             if (mozilla::ipc::LoggingEnabled()) {
     423               0 :                 (static_cast<const PStorage::Reply_GetValue*>(__reply))->Log("[PStorageParent] Sending reply ", stderr);
     424                 :             }
     425               0 :             return MsgProcessed;
     426                 :         }
     427                 :     case PStorage::Msg_SetValue__ID:
     428                 :         {
     429               0 :             (const_cast<Message&>(__msg)).set_name("PStorage::Msg_SetValue");
     430               0 :             if (mozilla::ipc::LoggingEnabled()) {
     431               0 :                 (static_cast<const PStorage::Msg_SetValue*>((&(__msg))))->Log("[PStorageParent] Received ", stderr);
     432                 :             }
     433                 : 
     434               0 :             void* __iter = 0;
     435                 :             bool callerSecure;
     436                 :             bool sessionOnly;
     437               0 :             nsString key;
     438               0 :             nsString data;
     439                 : 
     440               0 :             if ((!(Read((&(callerSecure)), (&(__msg)), (&(__iter)))))) {
     441               0 :                 FatalError("error deserializing (better message TODO)");
     442               0 :                 return MsgValueError;
     443                 :             }
     444               0 :             if ((!(Read((&(sessionOnly)), (&(__msg)), (&(__iter)))))) {
     445               0 :                 FatalError("error deserializing (better message TODO)");
     446               0 :                 return MsgValueError;
     447                 :             }
     448               0 :             if ((!(Read((&(key)), (&(__msg)), (&(__iter)))))) {
     449               0 :                 FatalError("error deserializing (better message TODO)");
     450               0 :                 return MsgValueError;
     451                 :             }
     452               0 :             if ((!(Read((&(data)), (&(__msg)), (&(__iter)))))) {
     453               0 :                 FatalError("error deserializing (better message TODO)");
     454               0 :                 return MsgValueError;
     455                 :             }
     456               0 :             (__msg).EndRead(__iter);
     457               0 :             if ((!(PStorage::Transition(mState, Trigger(Trigger::Recv, PStorage::Msg_SetValue__ID), (&(mState)))))) {
     458               0 :                 NS_WARNING("bad state transition!");
     459                 :             }
     460               0 :             nsString oldValue;
     461                 :             nsresult rv;
     462               0 :             int32 __id = mId;
     463               0 :             if ((!(RecvSetValue(callerSecure, sessionOnly, key, data, (&(oldValue)), (&(rv)))))) {
     464               0 :                 return MsgProcessingError;
     465                 :             }
     466                 : 
     467               0 :             __reply = new PStorage::Reply_SetValue();
     468                 : 
     469               0 :             Write(oldValue, __reply);
     470               0 :             Write(rv, __reply);
     471               0 :             (__reply)->set_routing_id(__id);
     472               0 :             (__reply)->set_sync();
     473               0 :             (__reply)->set_reply();
     474                 : 
     475               0 :             if (mozilla::ipc::LoggingEnabled()) {
     476               0 :                 (static_cast<const PStorage::Reply_SetValue*>(__reply))->Log("[PStorageParent] Sending reply ", stderr);
     477                 :             }
     478               0 :             return MsgProcessed;
     479                 :         }
     480                 :     case PStorage::Msg_RemoveValue__ID:
     481                 :         {
     482               0 :             (const_cast<Message&>(__msg)).set_name("PStorage::Msg_RemoveValue");
     483               0 :             if (mozilla::ipc::LoggingEnabled()) {
     484               0 :                 (static_cast<const PStorage::Msg_RemoveValue*>((&(__msg))))->Log("[PStorageParent] Received ", stderr);
     485                 :             }
     486                 : 
     487               0 :             void* __iter = 0;
     488                 :             bool callerSecure;
     489                 :             bool sessionOnly;
     490               0 :             nsString key;
     491                 : 
     492               0 :             if ((!(Read((&(callerSecure)), (&(__msg)), (&(__iter)))))) {
     493               0 :                 FatalError("error deserializing (better message TODO)");
     494               0 :                 return MsgValueError;
     495                 :             }
     496               0 :             if ((!(Read((&(sessionOnly)), (&(__msg)), (&(__iter)))))) {
     497               0 :                 FatalError("error deserializing (better message TODO)");
     498               0 :                 return MsgValueError;
     499                 :             }
     500               0 :             if ((!(Read((&(key)), (&(__msg)), (&(__iter)))))) {
     501               0 :                 FatalError("error deserializing (better message TODO)");
     502               0 :                 return MsgValueError;
     503                 :             }
     504               0 :             (__msg).EndRead(__iter);
     505               0 :             if ((!(PStorage::Transition(mState, Trigger(Trigger::Recv, PStorage::Msg_RemoveValue__ID), (&(mState)))))) {
     506               0 :                 NS_WARNING("bad state transition!");
     507                 :             }
     508               0 :             nsString oldValue;
     509                 :             nsresult rv;
     510               0 :             int32 __id = mId;
     511               0 :             if ((!(RecvRemoveValue(callerSecure, sessionOnly, key, (&(oldValue)), (&(rv)))))) {
     512               0 :                 return MsgProcessingError;
     513                 :             }
     514                 : 
     515               0 :             __reply = new PStorage::Reply_RemoveValue();
     516                 : 
     517               0 :             Write(oldValue, __reply);
     518               0 :             Write(rv, __reply);
     519               0 :             (__reply)->set_routing_id(__id);
     520               0 :             (__reply)->set_sync();
     521               0 :             (__reply)->set_reply();
     522                 : 
     523               0 :             if (mozilla::ipc::LoggingEnabled()) {
     524               0 :                 (static_cast<const PStorage::Reply_RemoveValue*>(__reply))->Log("[PStorageParent] Sending reply ", stderr);
     525                 :             }
     526               0 :             return MsgProcessed;
     527                 :         }
     528                 :     case PStorage::Msg_Clear__ID:
     529                 :         {
     530               0 :             (const_cast<Message&>(__msg)).set_name("PStorage::Msg_Clear");
     531               0 :             if (mozilla::ipc::LoggingEnabled()) {
     532               0 :                 (static_cast<const PStorage::Msg_Clear*>((&(__msg))))->Log("[PStorageParent] Received ", stderr);
     533                 :             }
     534                 : 
     535               0 :             void* __iter = 0;
     536                 :             bool callerSecure;
     537                 :             bool sessionOnly;
     538                 : 
     539               0 :             if ((!(Read((&(callerSecure)), (&(__msg)), (&(__iter)))))) {
     540               0 :                 FatalError("error deserializing (better message TODO)");
     541               0 :                 return MsgValueError;
     542                 :             }
     543               0 :             if ((!(Read((&(sessionOnly)), (&(__msg)), (&(__iter)))))) {
     544               0 :                 FatalError("error deserializing (better message TODO)");
     545               0 :                 return MsgValueError;
     546                 :             }
     547               0 :             (__msg).EndRead(__iter);
     548               0 :             if ((!(PStorage::Transition(mState, Trigger(Trigger::Recv, PStorage::Msg_Clear__ID), (&(mState)))))) {
     549               0 :                 NS_WARNING("bad state transition!");
     550                 :             }
     551                 :             PRInt32 oldCount;
     552                 :             nsresult rv;
     553               0 :             int32 __id = mId;
     554               0 :             if ((!(RecvClear(callerSecure, sessionOnly, (&(oldCount)), (&(rv)))))) {
     555               0 :                 return MsgProcessingError;
     556                 :             }
     557                 : 
     558               0 :             __reply = new PStorage::Reply_Clear();
     559                 : 
     560               0 :             Write(oldCount, __reply);
     561               0 :             Write(rv, __reply);
     562               0 :             (__reply)->set_routing_id(__id);
     563               0 :             (__reply)->set_sync();
     564               0 :             (__reply)->set_reply();
     565                 : 
     566               0 :             if (mozilla::ipc::LoggingEnabled()) {
     567               0 :                 (static_cast<const PStorage::Reply_Clear*>(__reply))->Log("[PStorageParent] Sending reply ", stderr);
     568                 :             }
     569               0 :             return MsgProcessed;
     570                 :         }
     571                 :     case PStorage::Msg_GetDBValue__ID:
     572                 :         {
     573               0 :             (const_cast<Message&>(__msg)).set_name("PStorage::Msg_GetDBValue");
     574               0 :             if (mozilla::ipc::LoggingEnabled()) {
     575               0 :                 (static_cast<const PStorage::Msg_GetDBValue*>((&(__msg))))->Log("[PStorageParent] Received ", stderr);
     576                 :             }
     577                 : 
     578               0 :             void* __iter = 0;
     579               0 :             nsString key;
     580                 : 
     581               0 :             if ((!(Read((&(key)), (&(__msg)), (&(__iter)))))) {
     582               0 :                 FatalError("error deserializing (better message TODO)");
     583               0 :                 return MsgValueError;
     584                 :             }
     585               0 :             (__msg).EndRead(__iter);
     586               0 :             if ((!(PStorage::Transition(mState, Trigger(Trigger::Recv, PStorage::Msg_GetDBValue__ID), (&(mState)))))) {
     587               0 :                 NS_WARNING("bad state transition!");
     588                 :             }
     589               0 :             nsString value;
     590                 :             bool secure;
     591                 :             nsresult rv;
     592               0 :             int32 __id = mId;
     593               0 :             if ((!(RecvGetDBValue(key, (&(value)), (&(secure)), (&(rv)))))) {
     594               0 :                 return MsgProcessingError;
     595                 :             }
     596                 : 
     597               0 :             __reply = new PStorage::Reply_GetDBValue();
     598                 : 
     599               0 :             Write(value, __reply);
     600               0 :             Write(secure, __reply);
     601               0 :             Write(rv, __reply);
     602               0 :             (__reply)->set_routing_id(__id);
     603               0 :             (__reply)->set_sync();
     604               0 :             (__reply)->set_reply();
     605                 : 
     606               0 :             if (mozilla::ipc::LoggingEnabled()) {
     607               0 :                 (static_cast<const PStorage::Reply_GetDBValue*>(__reply))->Log("[PStorageParent] Sending reply ", stderr);
     608                 :             }
     609               0 :             return MsgProcessed;
     610                 :         }
     611                 :     case PStorage::Msg_SetDBValue__ID:
     612                 :         {
     613               0 :             (const_cast<Message&>(__msg)).set_name("PStorage::Msg_SetDBValue");
     614               0 :             if (mozilla::ipc::LoggingEnabled()) {
     615               0 :                 (static_cast<const PStorage::Msg_SetDBValue*>((&(__msg))))->Log("[PStorageParent] Received ", stderr);
     616                 :             }
     617                 : 
     618               0 :             void* __iter = 0;
     619               0 :             nsString key;
     620               0 :             nsString value;
     621                 :             bool secure;
     622                 : 
     623               0 :             if ((!(Read((&(key)), (&(__msg)), (&(__iter)))))) {
     624               0 :                 FatalError("error deserializing (better message TODO)");
     625               0 :                 return MsgValueError;
     626                 :             }
     627               0 :             if ((!(Read((&(value)), (&(__msg)), (&(__iter)))))) {
     628               0 :                 FatalError("error deserializing (better message TODO)");
     629               0 :                 return MsgValueError;
     630                 :             }
     631               0 :             if ((!(Read((&(secure)), (&(__msg)), (&(__iter)))))) {
     632               0 :                 FatalError("error deserializing (better message TODO)");
     633               0 :                 return MsgValueError;
     634                 :             }
     635               0 :             (__msg).EndRead(__iter);
     636               0 :             if ((!(PStorage::Transition(mState, Trigger(Trigger::Recv, PStorage::Msg_SetDBValue__ID), (&(mState)))))) {
     637               0 :                 NS_WARNING("bad state transition!");
     638                 :             }
     639                 :             nsresult rv;
     640               0 :             int32 __id = mId;
     641               0 :             if ((!(RecvSetDBValue(key, value, secure, (&(rv)))))) {
     642               0 :                 return MsgProcessingError;
     643                 :             }
     644                 : 
     645               0 :             __reply = new PStorage::Reply_SetDBValue();
     646                 : 
     647               0 :             Write(rv, __reply);
     648               0 :             (__reply)->set_routing_id(__id);
     649               0 :             (__reply)->set_sync();
     650               0 :             (__reply)->set_reply();
     651                 : 
     652               0 :             if (mozilla::ipc::LoggingEnabled()) {
     653               0 :                 (static_cast<const PStorage::Reply_SetDBValue*>(__reply))->Log("[PStorageParent] Sending reply ", stderr);
     654                 :             }
     655               0 :             return MsgProcessed;
     656                 :         }
     657                 :     case PStorage::Msg_SetSecure__ID:
     658                 :         {
     659               0 :             (const_cast<Message&>(__msg)).set_name("PStorage::Msg_SetSecure");
     660               0 :             if (mozilla::ipc::LoggingEnabled()) {
     661               0 :                 (static_cast<const PStorage::Msg_SetSecure*>((&(__msg))))->Log("[PStorageParent] Received ", stderr);
     662                 :             }
     663                 : 
     664               0 :             void* __iter = 0;
     665               0 :             nsString key;
     666                 :             bool secure;
     667                 : 
     668               0 :             if ((!(Read((&(key)), (&(__msg)), (&(__iter)))))) {
     669               0 :                 FatalError("error deserializing (better message TODO)");
     670               0 :                 return MsgValueError;
     671                 :             }
     672               0 :             if ((!(Read((&(secure)), (&(__msg)), (&(__iter)))))) {
     673               0 :                 FatalError("error deserializing (better message TODO)");
     674               0 :                 return MsgValueError;
     675                 :             }
     676               0 :             (__msg).EndRead(__iter);
     677               0 :             if ((!(PStorage::Transition(mState, Trigger(Trigger::Recv, PStorage::Msg_SetSecure__ID), (&(mState)))))) {
     678               0 :                 NS_WARNING("bad state transition!");
     679                 :             }
     680                 :             nsresult rv;
     681               0 :             int32 __id = mId;
     682               0 :             if ((!(RecvSetSecure(key, secure, (&(rv)))))) {
     683               0 :                 return MsgProcessingError;
     684                 :             }
     685                 : 
     686               0 :             __reply = new PStorage::Reply_SetSecure();
     687                 : 
     688               0 :             Write(rv, __reply);
     689               0 :             (__reply)->set_routing_id(__id);
     690               0 :             (__reply)->set_sync();
     691               0 :             (__reply)->set_reply();
     692                 : 
     693               0 :             if (mozilla::ipc::LoggingEnabled()) {
     694               0 :                 (static_cast<const PStorage::Reply_SetSecure*>(__reply))->Log("[PStorageParent] Sending reply ", stderr);
     695                 :             }
     696               0 :             return MsgProcessed;
     697                 :         }
     698                 :     default:
     699                 :         {
     700               0 :             return MsgNotKnown;
     701                 :         }
     702                 :     }
     703                 : }
     704                 : 
     705                 : PStorageParent::Result
     706               0 : PStorageParent::OnCallReceived(
     707                 :         const Message& __msg,
     708                 :         Message*& __reply)
     709                 : {
     710               0 :     return MsgNotKnown;
     711                 : }
     712                 : 
     713                 : void
     714               0 : PStorageParent::OnProcessingError(Result code)
     715                 : {
     716               0 :     NS_RUNTIMEABORT("`OnProcessingError' called on non-toplevel actor");
     717               0 : }
     718                 : 
     719                 : bool
     720               0 : PStorageParent::OnReplyTimeout()
     721                 : {
     722               0 :     NS_RUNTIMEABORT("`OnReplyTimeout' called on non-toplevel actor");
     723               0 :     return false;
     724                 : }
     725                 : 
     726                 : void
     727               0 : PStorageParent::OnChannelClose()
     728                 : {
     729               0 :     NS_RUNTIMEABORT("`OnClose' called on non-toplevel actor");
     730               0 : }
     731                 : 
     732                 : void
     733               0 : PStorageParent::OnChannelError()
     734                 : {
     735               0 :     NS_RUNTIMEABORT("`OnError' called on non-toplevel actor");
     736               0 : }
     737                 : 
     738                 : void
     739               0 : PStorageParent::OnChannelConnected(int32 pid)
     740                 : {
     741               0 :     NS_RUNTIMEABORT("'OnConnected' called on non-toplevel actor");
     742               0 : }
     743                 : 
     744                 : bool
     745               0 : PStorageParent::AllocShmem(
     746                 :         size_t aSize,
     747                 :         Shmem::SharedMemory::SharedMemoryType aType,
     748                 :         Shmem* aMem)
     749                 : {
     750                 :     Shmem::id_t aId;
     751               0 :     nsAutoPtr<Shmem::SharedMemory> rawmem(CreateSharedMemory(aSize, aType, false, (&(aId))));
     752               0 :     if ((!(rawmem))) {
     753               0 :         return false;
     754                 :     }
     755                 : 
     756               0 :     (*(aMem)) = Shmem(Shmem::IHadBetterBeIPDLCodeCallingThis_OtherwiseIAmADoodyhead(), (rawmem).forget(), aId);
     757               0 :     return true;
     758                 : }
     759                 : 
     760                 : bool
     761               0 : PStorageParent::AllocUnsafeShmem(
     762                 :         size_t aSize,
     763                 :         Shmem::SharedMemory::SharedMemoryType aType,
     764                 :         Shmem* aMem)
     765                 : {
     766                 :     Shmem::id_t aId;
     767               0 :     nsAutoPtr<Shmem::SharedMemory> rawmem(CreateSharedMemory(aSize, aType, true, (&(aId))));
     768               0 :     if ((!(rawmem))) {
     769               0 :         return false;
     770                 :     }
     771                 : 
     772               0 :     (*(aMem)) = Shmem(Shmem::IHadBetterBeIPDLCodeCallingThis_OtherwiseIAmADoodyhead(), (rawmem).forget(), aId);
     773               0 :     return true;
     774                 : }
     775                 : 
     776                 : bool
     777               0 : PStorageParent::AdoptShmem(
     778                 :         Shmem& aMem,
     779                 :         Shmem* aOutMem)
     780                 : {
     781               0 :     Shmem::SharedMemory* rawmem = (aMem).Segment(Shmem::IHadBetterBeIPDLCodeCallingThis_OtherwiseIAmADoodyhead());
     782               0 :     if (((!(rawmem))) || (IsTrackingSharedMemory(rawmem))) {
     783               0 :         NS_RUNTIMEABORT("bad Shmem");
     784                 :     }
     785                 : 
     786                 :     Shmem::id_t aId;
     787               0 :     if ((!(AdoptSharedMemory(rawmem, (&(aId)))))) {
     788               0 :         return false;
     789                 :     }
     790                 : 
     791               0 :     (*(aOutMem)) = Shmem(Shmem::IHadBetterBeIPDLCodeCallingThis_OtherwiseIAmADoodyhead(), rawmem, aId);
     792               0 :     return true;
     793                 : }
     794                 : 
     795                 : bool
     796               0 : PStorageParent::DeallocShmem(Shmem& aMem)
     797                 : {
     798               0 :     bool ok = DestroySharedMemory(aMem);
     799               0 :     (aMem).forget(Shmem::IHadBetterBeIPDLCodeCallingThis_OtherwiseIAmADoodyhead());
     800               0 :     return ok;
     801                 : }
     802                 : 
     803                 : void
     804               0 : PStorageParent::FatalError(const char* const msg) const
     805                 : {
     806                 :     // Virtual method to prevent inlining.
     807                 :     // This give us better error reporting.
     808                 :     // See bug 589371
     809                 : 
     810               0 :     NS_ERROR("IPDL error:");
     811               0 :     NS_ERROR(msg);
     812                 : 
     813               0 :     NS_ERROR("[PStorageParent] killing child side as a result");
     814                 : 
     815               0 :     if ((!(base::KillProcess(OtherProcess(), base::PROCESS_END_KILLED_BY_USER, false)))) {
     816               0 :         NS_ERROR("  may have failed to kill child!");
     817                 :     }
     818               0 : }
     819                 : 
     820                 : void
     821               0 : PStorageParent::DestroySubtree(ActorDestroyReason why)
     822                 : {
     823                 :     // Unregister from our manager.
     824               0 :     Unregister(mId);
     825               0 :     mId = 1;
     826                 : 
     827                 :     // Finally, destroy "us".
     828               0 :     ActorDestroy(why);
     829               0 : }
     830                 : 
     831                 : void
     832               0 : PStorageParent::DeallocSubtree()
     833                 : {
     834               0 : }
     835                 : 
     836                 : void
     837               0 : PStorageParent::Write(
     838                 :         const ItemData& __v,
     839                 :         Message* __msg)
     840                 : {
     841               0 :     Write((__v).value(), __msg);
     842               0 :     Write((__v).secure(), __msg);
     843               0 : }
     844                 : 
     845                 : bool
     846               0 : PStorageParent::Read(
     847                 :         ItemData* __v,
     848                 :         const Message* __msg,
     849                 :         void** __iter)
     850                 : {
     851               0 :     if ((!(Read((&((__v)->value())), __msg, __iter)))) {
     852               0 :         return false;
     853                 :     }
     854               0 :     if ((!(Read((&((__v)->secure())), __msg, __iter)))) {
     855               0 :         return false;
     856                 :     }
     857               0 :     return true;
     858                 : }
     859                 : 
     860                 : void
     861               0 : PStorageParent::Write(
     862                 :         PStorageParent* __v,
     863                 :         Message* __msg,
     864                 :         bool __nullable)
     865                 : {
     866                 :     int32 id;
     867               0 :     if ((!(__v))) {
     868               0 :         if ((!(__nullable))) {
     869               0 :             NS_RUNTIMEABORT("NULL actor value passed to non-nullable param");
     870                 :         }
     871               0 :         id = 0;
     872                 :     }
     873                 :     else {
     874               0 :         id = (__v)->mId;
     875               0 :         if ((1) == (id)) {
     876               0 :             NS_RUNTIMEABORT("actor has been |delete|d");
     877                 :         }
     878                 :     }
     879                 : 
     880               0 :     Write(id, __msg);
     881               0 : }
     882                 : 
     883                 : bool
     884               0 : PStorageParent::Read(
     885                 :         PStorageParent** __v,
     886                 :         const Message* __msg,
     887                 :         void** __iter,
     888                 :         bool __nullable)
     889                 : {
     890                 :     int32 id;
     891               0 :     if ((!(Read((&(id)), __msg, __iter)))) {
     892               0 :         return false;
     893                 :     }
     894               0 :     if (((1) == (id)) || (((0) == (id)) && ((!(__nullable))))) {
     895               0 :         return false;
     896                 :     }
     897                 : 
     898               0 :     if ((0) == (id)) {
     899               0 :         (*(__v)) = 0;
     900                 :     }
     901                 :     else {
     902               0 :         (*(__v)) = static_cast<PStorageParent*>(Lookup(id));
     903               0 :         if ((!((*(__v))))) {
     904               0 :             return false;
     905                 :         }
     906                 :     }
     907               0 :     return true;
     908                 : }
     909                 : 
     910                 : void
     911               0 : PStorageParent::Write(
     912                 :         const StorageItem& __v,
     913                 :         Message* __msg)
     914                 : {
     915                 :     typedef StorageItem __type;
     916               0 :     Write(int((__v).type()), __msg);
     917                 : 
     918               0 :     switch ((__v).type()) {
     919                 :     case __type::Tnull_t:
     920                 :         {
     921               0 :             Write((__v).get_null_t(), __msg);
     922               0 :             return;
     923                 :         }
     924                 :     case __type::TItemData:
     925                 :         {
     926               0 :             Write((__v).get_ItemData(), __msg);
     927               0 :             return;
     928                 :         }
     929                 :     default:
     930                 :         {
     931               0 :             NS_RUNTIMEABORT("unknown union type");
     932               0 :             return;
     933                 :         }
     934                 :     }
     935                 : }
     936                 : 
     937                 : bool
     938               0 : PStorageParent::Read(
     939                 :         StorageItem* __v,
     940                 :         const Message* __msg,
     941                 :         void** __iter)
     942                 : {
     943                 :     typedef StorageItem __type;
     944                 :     int type;
     945               0 :     if ((!(Read((&(type)), __msg, __iter)))) {
     946               0 :         return false;
     947                 :     }
     948                 : 
     949               0 :     switch (type) {
     950                 :     case __type::Tnull_t:
     951                 :         {
     952               0 :             null_t tmp = null_t();
     953               0 :             (*(__v)) = tmp;
     954               0 :             return Read((&((__v)->get_null_t())), __msg, __iter);
     955                 :         }
     956                 :     case __type::TItemData:
     957                 :         {
     958               0 :             ItemData tmp = ItemData();
     959               0 :             (*(__v)) = tmp;
     960               0 :             return Read((&((__v)->get_ItemData())), __msg, __iter);
     961                 :         }
     962                 :     default:
     963                 :         {
     964               0 :             return false;
     965                 :         }
     966                 :     }
     967                 : }
     968                 : 
     969                 : 
     970                 : 
     971                 : } // namespace dom
     972                 : } // namespace mozilla

Generated by: LCOV version 1.7