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

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

Generated by: LCOV version 1.7