LCOV - app.info - objdir/ipc/ipdl/PStorageParent.cpp

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-07-07 | 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