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

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

           1                 : //
           2                 : // Automatically generated by ipdlc.
           3                 : // Edit at your own risk
           4                 : //
           5                 :
           6                 :
           7                 : #include "mozilla/dom/sms/PSmsChild.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::sms::SmsMessageData SmsMessageData;
          20                 : typedef mozilla::dom::sms::SmsFilterData SmsFilterData;
          21                 : typedef mozilla::ipc::Shmem Shmem;
          22                 : using mozilla::dom::PContentChild;
          23                 :
          24                 : namespace mozilla {
          25                 : namespace dom {
          26                 : namespace sms {
          27                 :
          28                 :
          29                 : void
          30               0 : PSmsChild::ActorDestroy(ActorDestroyReason why)
          31                 : {
          32               0 : }
          33                 :
          34               0 : PSmsChild::PSmsChild() :
          35                 :     mId(0),
          36               0 :     mState(PSms::__Dead)
          37                 : {
          38               0 :     MOZ_COUNT_CTOR(PSmsChild);
          39               0 : }
          40                 :
          41               0 : PSmsChild::~PSmsChild()
          42                 : {
          43               0 :     MOZ_COUNT_DTOR(PSmsChild);
          44               0 : }
          45                 :
          46                 : PContentChild*
          47               0 : PSmsChild::Manager()
          48                 : {
          49               0 :     return static_cast<PContentChild*>(mManager);
          50                 : }
          51                 :
          52                 : PSms::State
          53               0 : PSmsChild::state()
          54                 : {
          55               0 :     return mState;
          56                 : }
          57                 :
          58                 : bool
          59               0 : PSmsChild::SendHasSupport(bool* aHasSupport)
          60                 : {
          61               0 :     PSms::Msg_HasSupport* __msg = new PSms::Msg_HasSupport();
          62                 :
          63                 :
          64               0 :     (__msg)->set_routing_id(mId);
          65               0 :     (__msg)->set_sync();
          66                 :
          67                 :
          68               0 :     Message __reply;
          69                 :
          70               0 :     if (mozilla::ipc::LoggingEnabled()) {
          71               0 :         (__msg)->Log("[PSmsChild] Sending ", stderr);
          72                 :     }
          73               0 :     if ((!(PSms::Transition(mState, Trigger(Trigger::Recv, PSms::Msg_HasSupport__ID), (&(mState)))))) {
          74               0 :         NS_WARNING("bad state transition!");
          75                 :     }
          76                 :
          77               0 :     bool __sendok = (mChannel)->Send(__msg, (&(__reply)));
          78               0 :     if ((!(__sendok))) {
          79               0 :         return false;
          80                 :     }
          81                 :
          82               0 :     if (mozilla::ipc::LoggingEnabled()) {
          83               0 :         (static_cast<const PSms::Reply_HasSupport*>((&(__reply))))->Log("[PSmsChild] Received reply ", stderr);
          84                 :     }
          85                 :
          86               0 :     void* __iter = 0;
          87               0 :     if ((!(Read(aHasSupport, (&(__reply)), (&(__iter)))))) {
          88               0 :         FatalError("error deserializing (better message TODO)");
          89               0 :         return false;
          90                 :     }
          91               0 :     (__reply).EndRead(__iter);
          92                 :
          93               0 :     return true;
          94                 : }
          95                 :
          96                 : bool
          97               0 : PSmsChild::SendGetNumberOfMessagesForText(
          98                 :         const nsString& aText,
          99                 :         PRUint16* aNumber)
         100                 : {
         101               0 :     PSms::Msg_GetNumberOfMessagesForText* __msg = new PSms::Msg_GetNumberOfMessagesForText();
         102                 :
         103               0 :     Write(aText, __msg);
         104                 :
         105               0 :     (__msg)->set_routing_id(mId);
         106               0 :     (__msg)->set_sync();
         107                 :
         108                 :
         109               0 :     Message __reply;
         110                 :
         111               0 :     if (mozilla::ipc::LoggingEnabled()) {
         112               0 :         (__msg)->Log("[PSmsChild] Sending ", stderr);
         113                 :     }
         114               0 :     if ((!(PSms::Transition(mState, Trigger(Trigger::Recv, PSms::Msg_GetNumberOfMessagesForText__ID), (&(mState)))))) {
         115               0 :         NS_WARNING("bad state transition!");
         116                 :     }
         117                 :
         118               0 :     bool __sendok = (mChannel)->Send(__msg, (&(__reply)));
         119               0 :     if ((!(__sendok))) {
         120               0 :         return false;
         121                 :     }
         122                 :
         123               0 :     if (mozilla::ipc::LoggingEnabled()) {
         124               0 :         (static_cast<const PSms::Reply_GetNumberOfMessagesForText*>((&(__reply))))->Log("[PSmsChild] Received reply ", stderr);
         125                 :     }
         126                 :
         127               0 :     void* __iter = 0;
         128               0 :     if ((!(Read(aNumber, (&(__reply)), (&(__iter)))))) {
         129               0 :         FatalError("error deserializing (better message TODO)");
         130               0 :         return false;
         131                 :     }
         132               0 :     (__reply).EndRead(__iter);
         133                 :
         134               0 :     return true;
         135                 : }
         136                 :
         137                 : bool
         138               0 : PSmsChild::SendSendMessage(
         139                 :         const nsString& aNumber,
         140                 :         const nsString& aMessage,
         141                 :         const PRInt32& aRequestId,
         142                 :         const PRUint64& aProcessId)
         143                 : {
         144               0 :     PSms::Msg_SendMessage* __msg = new PSms::Msg_SendMessage();
         145                 :
         146               0 :     Write(aNumber, __msg);
         147               0 :     Write(aMessage, __msg);
         148               0 :     Write(aRequestId, __msg);
         149               0 :     Write(aProcessId, __msg);
         150                 :
         151               0 :     (__msg)->set_routing_id(mId);
         152                 :
         153                 :
         154                 :
         155               0 :     if (mozilla::ipc::LoggingEnabled()) {
         156               0 :         (__msg)->Log("[PSmsChild] Sending ", stderr);
         157                 :     }
         158               0 :     if ((!(PSms::Transition(mState, Trigger(Trigger::Recv, PSms::Msg_SendMessage__ID), (&(mState)))))) {
         159               0 :         NS_WARNING("bad state transition!");
         160                 :     }
         161                 :
         162               0 :     bool __sendok = (mChannel)->Send(__msg);
         163               0 :     return __sendok;
         164                 : }
         165                 :
         166                 : bool
         167               0 : PSmsChild::SendSaveReceivedMessage(
         168                 :         const nsString& aSender,
         169                 :         const nsString& aBody,
         170                 :         const PRUint64& aDate,
         171                 :         PRInt32* aId)
         172                 : {
         173               0 :     PSms::Msg_SaveReceivedMessage* __msg = new PSms::Msg_SaveReceivedMessage();
         174                 :
         175               0 :     Write(aSender, __msg);
         176               0 :     Write(aBody, __msg);
         177               0 :     Write(aDate, __msg);
         178                 :
         179               0 :     (__msg)->set_routing_id(mId);
         180               0 :     (__msg)->set_sync();
         181                 :
         182                 :
         183               0 :     Message __reply;
         184                 :
         185               0 :     if (mozilla::ipc::LoggingEnabled()) {
         186               0 :         (__msg)->Log("[PSmsChild] Sending ", stderr);
         187                 :     }
         188               0 :     if ((!(PSms::Transition(mState, Trigger(Trigger::Recv, PSms::Msg_SaveReceivedMessage__ID), (&(mState)))))) {
         189               0 :         NS_WARNING("bad state transition!");
         190                 :     }
         191                 :
         192               0 :     bool __sendok = (mChannel)->Send(__msg, (&(__reply)));
         193               0 :     if ((!(__sendok))) {
         194               0 :         return false;
         195                 :     }
         196                 :
         197               0 :     if (mozilla::ipc::LoggingEnabled()) {
         198               0 :         (static_cast<const PSms::Reply_SaveReceivedMessage*>((&(__reply))))->Log("[PSmsChild] Received reply ", stderr);
         199                 :     }
         200                 :
         201               0 :     void* __iter = 0;
         202               0 :     if ((!(Read(aId, (&(__reply)), (&(__iter)))))) {
         203               0 :         FatalError("error deserializing (better message TODO)");
         204               0 :         return false;
         205                 :     }
         206               0 :     (__reply).EndRead(__iter);
         207                 :
         208               0 :     return true;
         209                 : }
         210                 :
         211                 : bool
         212               0 : PSmsChild::SendSaveSentMessage(
         213                 :         const nsString& aReceiver,
         214                 :         const nsString& aBody,
         215                 :         const PRUint64& aDate,
         216                 :         PRInt32* aId)
         217                 : {
         218               0 :     PSms::Msg_SaveSentMessage* __msg = new PSms::Msg_SaveSentMessage();
         219                 :
         220               0 :     Write(aReceiver, __msg);
         221               0 :     Write(aBody, __msg);
         222               0 :     Write(aDate, __msg);
         223                 :
         224               0 :     (__msg)->set_routing_id(mId);
         225               0 :     (__msg)->set_sync();
         226                 :
         227                 :
         228               0 :     Message __reply;
         229                 :
         230               0 :     if (mozilla::ipc::LoggingEnabled()) {
         231               0 :         (__msg)->Log("[PSmsChild] Sending ", stderr);
         232                 :     }
         233               0 :     if ((!(PSms::Transition(mState, Trigger(Trigger::Recv, PSms::Msg_SaveSentMessage__ID), (&(mState)))))) {
         234               0 :         NS_WARNING("bad state transition!");
         235                 :     }
         236                 :
         237               0 :     bool __sendok = (mChannel)->Send(__msg, (&(__reply)));
         238               0 :     if ((!(__sendok))) {
         239               0 :         return false;
         240                 :     }
         241                 :
         242               0 :     if (mozilla::ipc::LoggingEnabled()) {
         243               0 :         (static_cast<const PSms::Reply_SaveSentMessage*>((&(__reply))))->Log("[PSmsChild] Received reply ", stderr);
         244                 :     }
         245                 :
         246               0 :     void* __iter = 0;
         247               0 :     if ((!(Read(aId, (&(__reply)), (&(__iter)))))) {
         248               0 :         FatalError("error deserializing (better message TODO)");
         249               0 :         return false;
         250                 :     }
         251               0 :     (__reply).EndRead(__iter);
         252                 :
         253               0 :     return true;
         254                 : }
         255                 :
         256                 : bool
         257               0 : PSmsChild::SendGetMessage(
         258                 :         const PRInt32& aMessageId,
         259                 :         const PRInt32& aRequestId,
         260                 :         const PRUint64& aProcessId)
         261                 : {
         262               0 :     PSms::Msg_GetMessage* __msg = new PSms::Msg_GetMessage();
         263                 :
         264               0 :     Write(aMessageId, __msg);
         265               0 :     Write(aRequestId, __msg);
         266               0 :     Write(aProcessId, __msg);
         267                 :
         268               0 :     (__msg)->set_routing_id(mId);
         269                 :
         270                 :
         271                 :
         272               0 :     if (mozilla::ipc::LoggingEnabled()) {
         273               0 :         (__msg)->Log("[PSmsChild] Sending ", stderr);
         274                 :     }
         275               0 :     if ((!(PSms::Transition(mState, Trigger(Trigger::Recv, PSms::Msg_GetMessage__ID), (&(mState)))))) {
         276               0 :         NS_WARNING("bad state transition!");
         277                 :     }
         278                 :
         279               0 :     bool __sendok = (mChannel)->Send(__msg);
         280               0 :     return __sendok;
         281                 : }
         282                 :
         283                 : bool
         284               0 : PSmsChild::SendDeleteMessage(
         285                 :         const PRInt32& aMessageId,
         286                 :         const PRInt32& aRequestId,
         287                 :         const PRUint64& aProcessId)
         288                 : {
         289               0 :     PSms::Msg_DeleteMessage* __msg = new PSms::Msg_DeleteMessage();
         290                 :
         291               0 :     Write(aMessageId, __msg);
         292               0 :     Write(aRequestId, __msg);
         293               0 :     Write(aProcessId, __msg);
         294                 :
         295               0 :     (__msg)->set_routing_id(mId);
         296                 :
         297                 :
         298                 :
         299               0 :     if (mozilla::ipc::LoggingEnabled()) {
         300               0 :         (__msg)->Log("[PSmsChild] Sending ", stderr);
         301                 :     }
         302               0 :     if ((!(PSms::Transition(mState, Trigger(Trigger::Recv, PSms::Msg_DeleteMessage__ID), (&(mState)))))) {
         303               0 :         NS_WARNING("bad state transition!");
         304                 :     }
         305                 :
         306               0 :     bool __sendok = (mChannel)->Send(__msg);
         307               0 :     return __sendok;
         308                 : }
         309                 :
         310                 : bool
         311               0 : PSmsChild::SendCreateMessageList(
         312                 :         const SmsFilterData& aFilter,
         313                 :         const bool& aReverse,
         314                 :         const PRInt32& aRequestId,
         315                 :         const PRUint64& aProcessId)
         316                 : {
         317               0 :     PSms::Msg_CreateMessageList* __msg = new PSms::Msg_CreateMessageList();
         318                 :
         319               0 :     Write(aFilter, __msg);
         320               0 :     Write(aReverse, __msg);
         321               0 :     Write(aRequestId, __msg);
         322               0 :     Write(aProcessId, __msg);
         323                 :
         324               0 :     (__msg)->set_routing_id(mId);
         325                 :
         326                 :
         327                 :
         328               0 :     if (mozilla::ipc::LoggingEnabled()) {
         329               0 :         (__msg)->Log("[PSmsChild] Sending ", stderr);
         330                 :     }
         331               0 :     if ((!(PSms::Transition(mState, Trigger(Trigger::Recv, PSms::Msg_CreateMessageList__ID), (&(mState)))))) {
         332               0 :         NS_WARNING("bad state transition!");
         333                 :     }
         334                 :
         335               0 :     bool __sendok = (mChannel)->Send(__msg);
         336               0 :     return __sendok;
         337                 : }
         338                 :
         339                 : bool
         340               0 : PSmsChild::SendGetNextMessageInList(
         341                 :         const PRInt32& aListId,
         342                 :         const PRInt32& aRequestId,
         343                 :         const PRUint64& aProcessId)
         344                 : {
         345               0 :     PSms::Msg_GetNextMessageInList* __msg = new PSms::Msg_GetNextMessageInList();
         346                 :
         347               0 :     Write(aListId, __msg);
         348               0 :     Write(aRequestId, __msg);
         349               0 :     Write(aProcessId, __msg);
         350                 :
         351               0 :     (__msg)->set_routing_id(mId);
         352                 :
         353                 :
         354                 :
         355               0 :     if (mozilla::ipc::LoggingEnabled()) {
         356               0 :         (__msg)->Log("[PSmsChild] Sending ", stderr);
         357                 :     }
         358               0 :     if ((!(PSms::Transition(mState, Trigger(Trigger::Recv, PSms::Msg_GetNextMessageInList__ID), (&(mState)))))) {
         359               0 :         NS_WARNING("bad state transition!");
         360                 :     }
         361                 :
         362               0 :     bool __sendok = (mChannel)->Send(__msg);
         363               0 :     return __sendok;
         364                 : }
         365                 :
         366                 : bool
         367               0 : PSmsChild::SendClearMessageList(const PRInt32& aListId)
         368                 : {
         369               0 :     PSms::Msg_ClearMessageList* __msg = new PSms::Msg_ClearMessageList();
         370                 :
         371               0 :     Write(aListId, __msg);
         372                 :
         373               0 :     (__msg)->set_routing_id(mId);
         374                 :
         375                 :
         376                 :
         377               0 :     if (mozilla::ipc::LoggingEnabled()) {
         378               0 :         (__msg)->Log("[PSmsChild] Sending ", stderr);
         379                 :     }
         380               0 :     if ((!(PSms::Transition(mState, Trigger(Trigger::Recv, PSms::Msg_ClearMessageList__ID), (&(mState)))))) {
         381               0 :         NS_WARNING("bad state transition!");
         382                 :     }
         383                 :
         384               0 :     bool __sendok = (mChannel)->Send(__msg);
         385               0 :     return __sendok;
         386                 : }
         387                 :
         388                 : bool
         389               0 : PSmsChild::Send__delete__(PSmsChild* actor)
         390                 : {
         391               0 :     if ((!(actor))) {
         392               0 :         return false;
         393                 :     }
         394                 :
         395               0 :     if ((!(actor))) {
         396               0 :         return false;
         397                 :     }
         398                 :
         399               0 :     PSms::Msg___delete__* __msg = new PSms::Msg___delete__();
         400                 :
         401               0 :     (actor)->Write(actor, __msg, false);
         402                 :
         403               0 :     (__msg)->set_routing_id((actor)->mId);
         404                 :
         405                 :
         406               0 :     if (mozilla::ipc::LoggingEnabled()) {
         407               0 :         (__msg)->Log("[PSmsChild] Sending ", stderr);
         408                 :     }
         409               0 :     if ((!(PSms::Transition((actor)->mState, Trigger(Trigger::Recv, PSms::Msg___delete____ID), (&((actor)->mState)))))) {
         410               0 :         NS_WARNING("bad state transition!");
         411                 :     }
         412                 :
         413               0 :     bool __sendok = ((actor)->mChannel)->Send(__msg);
         414                 :
         415               0 :     (actor)->DestroySubtree(Deletion);
         416               0 :     (actor)->DeallocSubtree();
         417               0 :     ((actor)->mManager)->RemoveManagee(PSmsMsgStart, actor);
         418               0 :     return __sendok;
         419                 : }
         420                 :
         421                 : int32
         422               0 : PSmsChild::Register(ChannelListener* aRouted)
         423                 : {
         424               0 :     return (mManager)->Register(aRouted);
         425                 : }
         426                 :
         427                 : int32
         428               0 : PSmsChild::RegisterID(
         429                 :         ChannelListener* aRouted,
         430                 :         int32 aId)
         431                 : {
         432               0 :     return (mManager)->RegisterID(aRouted, aId);
         433                 : }
         434                 :
         435                 : ChannelListener*
         436               0 : PSmsChild::Lookup(int32 aId)
         437                 : {
         438               0 :     return (mManager)->Lookup(aId);
         439                 : }
         440                 :
         441                 : void
         442               0 : PSmsChild::Unregister(int32 aId)
         443                 : {
         444               0 :     return (mManager)->Unregister(aId);
         445                 : }
         446                 :
         447                 : void
         448               0 : PSmsChild::RemoveManagee(
         449                 :         int32 aProtocolId,
         450                 :         ChannelListener* aListener)
         451                 : {
         452               0 :     NS_RUNTIMEABORT("unreached");
         453                 :     return;
         454                 : }
         455                 :
         456                 : Shmem::SharedMemory*
         457               0 : PSmsChild::CreateSharedMemory(
         458                 :         size_t aSize,
         459                 :         Shmem::SharedMemory::SharedMemoryType type,
         460                 :         bool unsafe,
         461                 :         Shmem::id_t* aId)
         462                 : {
         463               0 :     return (mManager)->CreateSharedMemory(aSize, type, unsafe, aId);
         464                 : }
         465                 :
         466                 : bool
         467               0 : PSmsChild::AdoptSharedMemory(
         468                 :         Shmem::SharedMemory* segment,
         469                 :         Shmem::id_t* aId)
         470                 : {
         471               0 :     return (mManager)->AdoptSharedMemory(segment, aId);
         472                 : }
         473                 :
         474                 : Shmem::SharedMemory*
         475               0 : PSmsChild::LookupSharedMemory(Shmem::id_t aId)
         476                 : {
         477               0 :     return (mManager)->LookupSharedMemory(aId);
         478                 : }
         479                 :
         480                 : bool
         481               0 : PSmsChild::IsTrackingSharedMemory(Shmem::SharedMemory* segment)
         482                 : {
         483               0 :     return (mManager)->IsTrackingSharedMemory(segment);
         484                 : }
         485                 :
         486                 : bool
         487               0 : PSmsChild::DestroySharedMemory(Shmem& aShmem)
         488                 : {
         489               0 :     return (mManager)->DestroySharedMemory(aShmem);
         490                 : }
         491                 :
         492                 : ProcessHandle
         493               0 : PSmsChild::OtherProcess() const
         494                 : {
         495               0 :     return (mManager)->OtherProcess();
         496                 : }
         497                 :
         498                 : AsyncChannel*
         499               0 : PSmsChild::GetIPCChannel()
         500                 : {
         501               0 :     return mChannel;
         502                 : }
         503                 :
         504                 : PSmsChild::Result
         505               0 : PSmsChild::OnMessageReceived(const Message& __msg)
         506                 : {
         507               0 :     switch ((__msg).type()) {
         508                 :     case PSms::Msg_NotifyReceivedMessage__ID:
         509                 :         {
         510               0 :             (const_cast<Message&>(__msg)).set_name("PSms::Msg_NotifyReceivedMessage");
         511               0 :             if (mozilla::ipc::LoggingEnabled()) {
         512               0 :                 (static_cast<const PSms::Msg_NotifyReceivedMessage*>((&(__msg))))->Log("[PSmsChild] Received ", stderr);
         513                 :             }
         514                 :
         515               0 :             void* __iter = 0;
         516               0 :             SmsMessageData aMessageData;
         517                 :
         518               0 :             if ((!(Read((&(aMessageData)), (&(__msg)), (&(__iter)))))) {
         519               0 :                 FatalError("error deserializing (better message TODO)");
         520               0 :                 return MsgValueError;
         521                 :             }
         522               0 :             (__msg).EndRead(__iter);
         523               0 :             if ((!(PSms::Transition(mState, Trigger(Trigger::Send, PSms::Msg_NotifyReceivedMessage__ID), (&(mState)))))) {
         524               0 :                 NS_WARNING("bad state transition!");
         525                 :             }
         526               0 :             if ((!(RecvNotifyReceivedMessage(aMessageData)))) {
         527               0 :                 return MsgProcessingError;
         528                 :             }
         529                 :
         530               0 :             return MsgProcessed;
         531                 :         }
         532                 :     case PSms::Msg_NotifySentMessage__ID:
         533                 :         {
         534               0 :             (const_cast<Message&>(__msg)).set_name("PSms::Msg_NotifySentMessage");
         535               0 :             if (mozilla::ipc::LoggingEnabled()) {
         536               0 :                 (static_cast<const PSms::Msg_NotifySentMessage*>((&(__msg))))->Log("[PSmsChild] Received ", stderr);
         537                 :             }
         538                 :
         539               0 :             void* __iter = 0;
         540               0 :             SmsMessageData aMessageData;
         541                 :
         542               0 :             if ((!(Read((&(aMessageData)), (&(__msg)), (&(__iter)))))) {
         543               0 :                 FatalError("error deserializing (better message TODO)");
         544               0 :                 return MsgValueError;
         545                 :             }
         546               0 :             (__msg).EndRead(__iter);
         547               0 :             if ((!(PSms::Transition(mState, Trigger(Trigger::Send, PSms::Msg_NotifySentMessage__ID), (&(mState)))))) {
         548               0 :                 NS_WARNING("bad state transition!");
         549                 :             }
         550               0 :             if ((!(RecvNotifySentMessage(aMessageData)))) {
         551               0 :                 return MsgProcessingError;
         552                 :             }
         553                 :
         554               0 :             return MsgProcessed;
         555                 :         }
         556                 :     case PSms::Msg_NotifyDeliveredMessage__ID:
         557                 :         {
         558               0 :             (const_cast<Message&>(__msg)).set_name("PSms::Msg_NotifyDeliveredMessage");
         559               0 :             if (mozilla::ipc::LoggingEnabled()) {
         560               0 :                 (static_cast<const PSms::Msg_NotifyDeliveredMessage*>((&(__msg))))->Log("[PSmsChild] Received ", stderr);
         561                 :             }
         562                 :
         563               0 :             void* __iter = 0;
         564               0 :             SmsMessageData aMessageData;
         565                 :
         566               0 :             if ((!(Read((&(aMessageData)), (&(__msg)), (&(__iter)))))) {
         567               0 :                 FatalError("error deserializing (better message TODO)");
         568               0 :                 return MsgValueError;
         569                 :             }
         570               0 :             (__msg).EndRead(__iter);
         571               0 :             if ((!(PSms::Transition(mState, Trigger(Trigger::Send, PSms::Msg_NotifyDeliveredMessage__ID), (&(mState)))))) {
         572               0 :                 NS_WARNING("bad state transition!");
         573                 :             }
         574               0 :             if ((!(RecvNotifyDeliveredMessage(aMessageData)))) {
         575               0 :                 return MsgProcessingError;
         576                 :             }
         577                 :
         578               0 :             return MsgProcessed;
         579                 :         }
         580                 :     case PSms::Msg_NotifyRequestSmsSent__ID:
         581                 :         {
         582               0 :             (const_cast<Message&>(__msg)).set_name("PSms::Msg_NotifyRequestSmsSent");
         583               0 :             if (mozilla::ipc::LoggingEnabled()) {
         584               0 :                 (static_cast<const PSms::Msg_NotifyRequestSmsSent*>((&(__msg))))->Log("[PSmsChild] Received ", stderr);
         585                 :             }
         586                 :
         587               0 :             void* __iter = 0;
         588               0 :             SmsMessageData aMessageData;
         589                 :             PRInt32 aRequestId;
         590                 :             PRUint64 aProcessId;
         591                 :
         592               0 :             if ((!(Read((&(aMessageData)), (&(__msg)), (&(__iter)))))) {
         593               0 :                 FatalError("error deserializing (better message TODO)");
         594               0 :                 return MsgValueError;
         595                 :             }
         596               0 :             if ((!(Read((&(aRequestId)), (&(__msg)), (&(__iter)))))) {
         597               0 :                 FatalError("error deserializing (better message TODO)");
         598               0 :                 return MsgValueError;
         599                 :             }
         600               0 :             if ((!(Read((&(aProcessId)), (&(__msg)), (&(__iter)))))) {
         601               0 :                 FatalError("error deserializing (better message TODO)");
         602               0 :                 return MsgValueError;
         603                 :             }
         604               0 :             (__msg).EndRead(__iter);
         605               0 :             if ((!(PSms::Transition(mState, Trigger(Trigger::Send, PSms::Msg_NotifyRequestSmsSent__ID), (&(mState)))))) {
         606               0 :                 NS_WARNING("bad state transition!");
         607                 :             }
         608               0 :             if ((!(RecvNotifyRequestSmsSent(aMessageData, aRequestId, aProcessId)))) {
         609               0 :                 return MsgProcessingError;
         610                 :             }
         611                 :
         612               0 :             return MsgProcessed;
         613                 :         }
         614                 :     case PSms::Msg_NotifyRequestSmsSendFailed__ID:
         615                 :         {
         616               0 :             (const_cast<Message&>(__msg)).set_name("PSms::Msg_NotifyRequestSmsSendFailed");
         617               0 :             if (mozilla::ipc::LoggingEnabled()) {
         618               0 :                 (static_cast<const PSms::Msg_NotifyRequestSmsSendFailed*>((&(__msg))))->Log("[PSmsChild] Received ", stderr);
         619                 :             }
         620                 :
         621               0 :             void* __iter = 0;
         622                 :             PRInt32 aError;
         623                 :             PRInt32 aRequestId;
         624                 :             PRUint64 aProcessId;
         625                 :
         626               0 :             if ((!(Read((&(aError)), (&(__msg)), (&(__iter)))))) {
         627               0 :                 FatalError("error deserializing (better message TODO)");
         628               0 :                 return MsgValueError;
         629                 :             }
         630               0 :             if ((!(Read((&(aRequestId)), (&(__msg)), (&(__iter)))))) {
         631               0 :                 FatalError("error deserializing (better message TODO)");
         632               0 :                 return MsgValueError;
         633                 :             }
         634               0 :             if ((!(Read((&(aProcessId)), (&(__msg)), (&(__iter)))))) {
         635               0 :                 FatalError("error deserializing (better message TODO)");
         636               0 :                 return MsgValueError;
         637                 :             }
         638               0 :             (__msg).EndRead(__iter);
         639               0 :             if ((!(PSms::Transition(mState, Trigger(Trigger::Send, PSms::Msg_NotifyRequestSmsSendFailed__ID), (&(mState)))))) {
         640               0 :                 NS_WARNING("bad state transition!");
         641                 :             }
         642               0 :             if ((!(RecvNotifyRequestSmsSendFailed(aError, aRequestId, aProcessId)))) {
         643               0 :                 return MsgProcessingError;
         644                 :             }
         645                 :
         646               0 :             return MsgProcessed;
         647                 :         }
         648                 :     case PSms::Msg_NotifyRequestGotSms__ID:
         649                 :         {
         650               0 :             (const_cast<Message&>(__msg)).set_name("PSms::Msg_NotifyRequestGotSms");
         651               0 :             if (mozilla::ipc::LoggingEnabled()) {
         652               0 :                 (static_cast<const PSms::Msg_NotifyRequestGotSms*>((&(__msg))))->Log("[PSmsChild] Received ", stderr);
         653                 :             }
         654                 :
         655               0 :             void* __iter = 0;
         656               0 :             SmsMessageData aMessageData;
         657                 :             PRInt32 aRequestId;
         658                 :             PRUint64 aProcessId;
         659                 :
         660               0 :             if ((!(Read((&(aMessageData)), (&(__msg)), (&(__iter)))))) {
         661               0 :                 FatalError("error deserializing (better message TODO)");
         662               0 :                 return MsgValueError;
         663                 :             }
         664               0 :             if ((!(Read((&(aRequestId)), (&(__msg)), (&(__iter)))))) {
         665               0 :                 FatalError("error deserializing (better message TODO)");
         666               0 :                 return MsgValueError;
         667                 :             }
         668               0 :             if ((!(Read((&(aProcessId)), (&(__msg)), (&(__iter)))))) {
         669               0 :                 FatalError("error deserializing (better message TODO)");
         670               0 :                 return MsgValueError;
         671                 :             }
         672               0 :             (__msg).EndRead(__iter);
         673               0 :             if ((!(PSms::Transition(mState, Trigger(Trigger::Send, PSms::Msg_NotifyRequestGotSms__ID), (&(mState)))))) {
         674               0 :                 NS_WARNING("bad state transition!");
         675                 :             }
         676               0 :             if ((!(RecvNotifyRequestGotSms(aMessageData, aRequestId, aProcessId)))) {
         677               0 :                 return MsgProcessingError;
         678                 :             }
         679                 :
         680               0 :             return MsgProcessed;
         681                 :         }
         682                 :     case PSms::Msg_NotifyRequestGetSmsFailed__ID:
         683                 :         {
         684               0 :             (const_cast<Message&>(__msg)).set_name("PSms::Msg_NotifyRequestGetSmsFailed");
         685               0 :             if (mozilla::ipc::LoggingEnabled()) {
         686               0 :                 (static_cast<const PSms::Msg_NotifyRequestGetSmsFailed*>((&(__msg))))->Log("[PSmsChild] Received ", stderr);
         687                 :             }
         688                 :
         689               0 :             void* __iter = 0;
         690                 :             PRInt32 aError;
         691                 :             PRInt32 aRequestId;
         692                 :             PRUint64 aProcessId;
         693                 :
         694               0 :             if ((!(Read((&(aError)), (&(__msg)), (&(__iter)))))) {
         695               0 :                 FatalError("error deserializing (better message TODO)");
         696               0 :                 return MsgValueError;
         697                 :             }
         698               0 :             if ((!(Read((&(aRequestId)), (&(__msg)), (&(__iter)))))) {
         699               0 :                 FatalError("error deserializing (better message TODO)");
         700               0 :                 return MsgValueError;
         701                 :             }
         702               0 :             if ((!(Read((&(aProcessId)), (&(__msg)), (&(__iter)))))) {
         703               0 :                 FatalError("error deserializing (better message TODO)");
         704               0 :                 return MsgValueError;
         705                 :             }
         706               0 :             (__msg).EndRead(__iter);
         707               0 :             if ((!(PSms::Transition(mState, Trigger(Trigger::Send, PSms::Msg_NotifyRequestGetSmsFailed__ID), (&(mState)))))) {
         708               0 :                 NS_WARNING("bad state transition!");
         709                 :             }
         710               0 :             if ((!(RecvNotifyRequestGetSmsFailed(aError, aRequestId, aProcessId)))) {
         711               0 :                 return MsgProcessingError;
         712                 :             }
         713                 :
         714               0 :             return MsgProcessed;
         715                 :         }
         716                 :     case PSms::Msg_NotifyRequestSmsDeleted__ID:
         717                 :         {
         718               0 :             (const_cast<Message&>(__msg)).set_name("PSms::Msg_NotifyRequestSmsDeleted");
         719               0 :             if (mozilla::ipc::LoggingEnabled()) {
         720               0 :                 (static_cast<const PSms::Msg_NotifyRequestSmsDeleted*>((&(__msg))))->Log("[PSmsChild] Received ", stderr);
         721                 :             }
         722                 :
         723               0 :             void* __iter = 0;
         724                 :             bool aDeleted;
         725                 :             PRInt32 aRequestId;
         726                 :             PRUint64 aProcessId;
         727                 :
         728               0 :             if ((!(Read((&(aDeleted)), (&(__msg)), (&(__iter)))))) {
         729               0 :                 FatalError("error deserializing (better message TODO)");
         730               0 :                 return MsgValueError;
         731                 :             }
         732               0 :             if ((!(Read((&(aRequestId)), (&(__msg)), (&(__iter)))))) {
         733               0 :                 FatalError("error deserializing (better message TODO)");
         734               0 :                 return MsgValueError;
         735                 :             }
         736               0 :             if ((!(Read((&(aProcessId)), (&(__msg)), (&(__iter)))))) {
         737               0 :                 FatalError("error deserializing (better message TODO)");
         738               0 :                 return MsgValueError;
         739                 :             }
         740               0 :             (__msg).EndRead(__iter);
         741               0 :             if ((!(PSms::Transition(mState, Trigger(Trigger::Send, PSms::Msg_NotifyRequestSmsDeleted__ID), (&(mState)))))) {
         742               0 :                 NS_WARNING("bad state transition!");
         743                 :             }
         744               0 :             if ((!(RecvNotifyRequestSmsDeleted(aDeleted, aRequestId, aProcessId)))) {
         745               0 :                 return MsgProcessingError;
         746                 :             }
         747                 :
         748               0 :             return MsgProcessed;
         749                 :         }
         750                 :     case PSms::Msg_NotifyRequestSmsDeleteFailed__ID:
         751                 :         {
         752               0 :             (const_cast<Message&>(__msg)).set_name("PSms::Msg_NotifyRequestSmsDeleteFailed");
         753               0 :             if (mozilla::ipc::LoggingEnabled()) {
         754               0 :                 (static_cast<const PSms::Msg_NotifyRequestSmsDeleteFailed*>((&(__msg))))->Log("[PSmsChild] Received ", stderr);
         755                 :             }
         756                 :
         757               0 :             void* __iter = 0;
         758                 :             PRInt32 aError;
         759                 :             PRInt32 aRequestId;
         760                 :             PRUint64 aProcessId;
         761                 :
         762               0 :             if ((!(Read((&(aError)), (&(__msg)), (&(__iter)))))) {
         763               0 :                 FatalError("error deserializing (better message TODO)");
         764               0 :                 return MsgValueError;
         765                 :             }
         766               0 :             if ((!(Read((&(aRequestId)), (&(__msg)), (&(__iter)))))) {
         767               0 :                 FatalError("error deserializing (better message TODO)");
         768               0 :                 return MsgValueError;
         769                 :             }
         770               0 :             if ((!(Read((&(aProcessId)), (&(__msg)), (&(__iter)))))) {
         771               0 :                 FatalError("error deserializing (better message TODO)");
         772               0 :                 return MsgValueError;
         773                 :             }
         774               0 :             (__msg).EndRead(__iter);
         775               0 :             if ((!(PSms::Transition(mState, Trigger(Trigger::Send, PSms::Msg_NotifyRequestSmsDeleteFailed__ID), (&(mState)))))) {
         776               0 :                 NS_WARNING("bad state transition!");
         777                 :             }
         778               0 :             if ((!(RecvNotifyRequestSmsDeleteFailed(aError, aRequestId, aProcessId)))) {
         779               0 :                 return MsgProcessingError;
         780                 :             }
         781                 :
         782               0 :             return MsgProcessed;
         783                 :         }
         784                 :     case PSms::Msg_NotifyRequestNoMessageInList__ID:
         785                 :         {
         786               0 :             (const_cast<Message&>(__msg)).set_name("PSms::Msg_NotifyRequestNoMessageInList");
         787               0 :             if (mozilla::ipc::LoggingEnabled()) {
         788               0 :                 (static_cast<const PSms::Msg_NotifyRequestNoMessageInList*>((&(__msg))))->Log("[PSmsChild] Received ", stderr);
         789                 :             }
         790                 :
         791               0 :             void* __iter = 0;
         792                 :             PRInt32 aRequestId;
         793                 :             PRUint64 aProcessId;
         794                 :
         795               0 :             if ((!(Read((&(aRequestId)), (&(__msg)), (&(__iter)))))) {
         796               0 :                 FatalError("error deserializing (better message TODO)");
         797               0 :                 return MsgValueError;
         798                 :             }
         799               0 :             if ((!(Read((&(aProcessId)), (&(__msg)), (&(__iter)))))) {
         800               0 :                 FatalError("error deserializing (better message TODO)");
         801               0 :                 return MsgValueError;
         802                 :             }
         803               0 :             (__msg).EndRead(__iter);
         804               0 :             if ((!(PSms::Transition(mState, Trigger(Trigger::Send, PSms::Msg_NotifyRequestNoMessageInList__ID), (&(mState)))))) {
         805               0 :                 NS_WARNING("bad state transition!");
         806                 :             }
         807               0 :             if ((!(RecvNotifyRequestNoMessageInList(aRequestId, aProcessId)))) {
         808               0 :                 return MsgProcessingError;
         809                 :             }
         810                 :
         811               0 :             return MsgProcessed;
         812                 :         }
         813                 :     case PSms::Msg_NotifyRequestCreateMessageList__ID:
         814                 :         {
         815               0 :             (const_cast<Message&>(__msg)).set_name("PSms::Msg_NotifyRequestCreateMessageList");
         816               0 :             if (mozilla::ipc::LoggingEnabled()) {
         817               0 :                 (static_cast<const PSms::Msg_NotifyRequestCreateMessageList*>((&(__msg))))->Log("[PSmsChild] Received ", stderr);
         818                 :             }
         819                 :
         820               0 :             void* __iter = 0;
         821                 :             PRInt32 aListId;
         822               0 :             SmsMessageData aMessageData;
         823                 :             PRInt32 aRequestId;
         824                 :             PRUint64 aProcessId;
         825                 :
         826               0 :             if ((!(Read((&(aListId)), (&(__msg)), (&(__iter)))))) {
         827               0 :                 FatalError("error deserializing (better message TODO)");
         828               0 :                 return MsgValueError;
         829                 :             }
         830               0 :             if ((!(Read((&(aMessageData)), (&(__msg)), (&(__iter)))))) {
         831               0 :                 FatalError("error deserializing (better message TODO)");
         832               0 :                 return MsgValueError;
         833                 :             }
         834               0 :             if ((!(Read((&(aRequestId)), (&(__msg)), (&(__iter)))))) {
         835               0 :                 FatalError("error deserializing (better message TODO)");
         836               0 :                 return MsgValueError;
         837                 :             }
         838               0 :             if ((!(Read((&(aProcessId)), (&(__msg)), (&(__iter)))))) {
         839               0 :                 FatalError("error deserializing (better message TODO)");
         840               0 :                 return MsgValueError;
         841                 :             }
         842               0 :             (__msg).EndRead(__iter);
         843               0 :             if ((!(PSms::Transition(mState, Trigger(Trigger::Send, PSms::Msg_NotifyRequestCreateMessageList__ID), (&(mState)))))) {
         844               0 :                 NS_WARNING("bad state transition!");
         845                 :             }
         846               0 :             if ((!(RecvNotifyRequestCreateMessageList(aListId, aMessageData, aRequestId, aProcessId)))) {
         847               0 :                 return MsgProcessingError;
         848                 :             }
         849                 :
         850               0 :             return MsgProcessed;
         851                 :         }
         852                 :     case PSms::Msg_NotifyRequestGotNextMessage__ID:
         853                 :         {
         854               0 :             (const_cast<Message&>(__msg)).set_name("PSms::Msg_NotifyRequestGotNextMessage");
         855               0 :             if (mozilla::ipc::LoggingEnabled()) {
         856               0 :                 (static_cast<const PSms::Msg_NotifyRequestGotNextMessage*>((&(__msg))))->Log("[PSmsChild] Received ", stderr);
         857                 :             }
         858                 :
         859               0 :             void* __iter = 0;
         860               0 :             SmsMessageData aMessageData;
         861                 :             PRInt32 aRequestId;
         862                 :             PRUint64 aProcessId;
         863                 :
         864               0 :             if ((!(Read((&(aMessageData)), (&(__msg)), (&(__iter)))))) {
         865               0 :                 FatalError("error deserializing (better message TODO)");
         866               0 :                 return MsgValueError;
         867                 :             }
         868               0 :             if ((!(Read((&(aRequestId)), (&(__msg)), (&(__iter)))))) {
         869               0 :                 FatalError("error deserializing (better message TODO)");
         870               0 :                 return MsgValueError;
         871                 :             }
         872               0 :             if ((!(Read((&(aProcessId)), (&(__msg)), (&(__iter)))))) {
         873               0 :                 FatalError("error deserializing (better message TODO)");
         874               0 :                 return MsgValueError;
         875                 :             }
         876               0 :             (__msg).EndRead(__iter);
         877               0 :             if ((!(PSms::Transition(mState, Trigger(Trigger::Send, PSms::Msg_NotifyRequestGotNextMessage__ID), (&(mState)))))) {
         878               0 :                 NS_WARNING("bad state transition!");
         879                 :             }
         880               0 :             if ((!(RecvNotifyRequestGotNextMessage(aMessageData, aRequestId, aProcessId)))) {
         881               0 :                 return MsgProcessingError;
         882                 :             }
         883                 :
         884               0 :             return MsgProcessed;
         885                 :         }
         886                 :     case PSms::Msg_NotifyRequestReadListFailed__ID:
         887                 :         {
         888               0 :             (const_cast<Message&>(__msg)).set_name("PSms::Msg_NotifyRequestReadListFailed");
         889               0 :             if (mozilla::ipc::LoggingEnabled()) {
         890               0 :                 (static_cast<const PSms::Msg_NotifyRequestReadListFailed*>((&(__msg))))->Log("[PSmsChild] Received ", stderr);
         891                 :             }
         892                 :
         893               0 :             void* __iter = 0;
         894                 :             PRInt32 aError;
         895                 :             PRInt32 aRequestId;
         896                 :             PRUint64 aProcessId;
         897                 :
         898               0 :             if ((!(Read((&(aError)), (&(__msg)), (&(__iter)))))) {
         899               0 :                 FatalError("error deserializing (better message TODO)");
         900               0 :                 return MsgValueError;
         901                 :             }
         902               0 :             if ((!(Read((&(aRequestId)), (&(__msg)), (&(__iter)))))) {
         903               0 :                 FatalError("error deserializing (better message TODO)");
         904               0 :                 return MsgValueError;
         905                 :             }
         906               0 :             if ((!(Read((&(aProcessId)), (&(__msg)), (&(__iter)))))) {
         907               0 :                 FatalError("error deserializing (better message TODO)");
         908               0 :                 return MsgValueError;
         909                 :             }
         910               0 :             (__msg).EndRead(__iter);
         911               0 :             if ((!(PSms::Transition(mState, Trigger(Trigger::Send, PSms::Msg_NotifyRequestReadListFailed__ID), (&(mState)))))) {
         912               0 :                 NS_WARNING("bad state transition!");
         913                 :             }
         914               0 :             if ((!(RecvNotifyRequestReadListFailed(aError, aRequestId, aProcessId)))) {
         915               0 :                 return MsgProcessingError;
         916                 :             }
         917                 :
         918               0 :             return MsgProcessed;
         919                 :         }
         920                 :     case PSms::Reply___delete____ID:
         921                 :         {
         922               0 :             return MsgProcessed;
         923                 :         }
         924                 :     default:
         925                 :         {
         926               0 :             return MsgNotKnown;
         927                 :         }
         928                 :     }
         929                 : }
         930                 :
         931                 : PSmsChild::Result
         932               0 : PSmsChild::OnMessageReceived(
         933                 :         const Message& __msg,
         934                 :         Message*& __reply)
         935                 : {
         936               0 :     return MsgNotKnown;
         937                 : }
         938                 :
         939                 : PSmsChild::Result
         940               0 : PSmsChild::OnCallReceived(
         941                 :         const Message& __msg,
         942                 :         Message*& __reply)
         943                 : {
         944               0 :     return MsgNotKnown;
         945                 : }
         946                 :
         947                 : void
         948               0 : PSmsChild::OnProcessingError(Result code)
         949                 : {
         950               0 :     NS_RUNTIMEABORT("`OnProcessingError' called on non-toplevel actor");
         951               0 : }
         952                 :
         953                 : bool
         954               0 : PSmsChild::OnReplyTimeout()
         955                 : {
         956               0 :     NS_RUNTIMEABORT("`OnReplyTimeout' called on non-toplevel actor");
         957               0 :     return false;
         958                 : }
         959                 :
         960                 : void
         961               0 : PSmsChild::OnChannelClose()
         962                 : {
         963               0 :     NS_RUNTIMEABORT("`OnClose' called on non-toplevel actor");
         964               0 : }
         965                 :
         966                 : void
         967               0 : PSmsChild::OnChannelError()
         968                 : {
         969               0 :     NS_RUNTIMEABORT("`OnError' called on non-toplevel actor");
         970               0 : }
         971                 :
         972                 : void
         973               0 : PSmsChild::OnChannelConnected(int32 pid)
         974                 : {
         975               0 :     NS_RUNTIMEABORT("'OnConnected' called on non-toplevel actor");
         976               0 : }
         977                 :
         978                 : bool
         979               0 : PSmsChild::AllocShmem(
         980                 :         size_t aSize,
         981                 :         Shmem::SharedMemory::SharedMemoryType aType,
         982                 :         Shmem* aMem)
         983                 : {
         984                 :     Shmem::id_t aId;
         985               0 :     nsAutoPtr<Shmem::SharedMemory> rawmem(CreateSharedMemory(aSize, aType, false, (&(aId))));
         986               0 :     if ((!(rawmem))) {
         987               0 :         return false;
         988                 :     }
         989                 :
         990               0 :     (*(aMem)) = Shmem(Shmem::IHadBetterBeIPDLCodeCallingThis_OtherwiseIAmADoodyhead(), (rawmem).forget(), aId);
         991               0 :     return true;
         992                 : }
         993                 :
         994                 : bool
         995               0 : PSmsChild::AllocUnsafeShmem(
         996                 :         size_t aSize,
         997                 :         Shmem::SharedMemory::SharedMemoryType aType,
         998                 :         Shmem* aMem)
         999                 : {
        1000                 :     Shmem::id_t aId;
        1001               0 :     nsAutoPtr<Shmem::SharedMemory> rawmem(CreateSharedMemory(aSize, aType, true, (&(aId))));
        1002               0 :     if ((!(rawmem))) {
        1003               0 :         return false;
        1004                 :     }
        1005                 :
        1006               0 :     (*(aMem)) = Shmem(Shmem::IHadBetterBeIPDLCodeCallingThis_OtherwiseIAmADoodyhead(), (rawmem).forget(), aId);
        1007               0 :     return true;
        1008                 : }
        1009                 :
        1010                 : bool
        1011               0 : PSmsChild::AdoptShmem(
        1012                 :         Shmem& aMem,
        1013                 :         Shmem* aOutMem)
        1014                 : {
        1015               0 :     Shmem::SharedMemory* rawmem = (aMem).Segment(Shmem::IHadBetterBeIPDLCodeCallingThis_OtherwiseIAmADoodyhead());
        1016               0 :     if (((!(rawmem))) || (IsTrackingSharedMemory(rawmem))) {
        1017               0 :         NS_RUNTIMEABORT("bad Shmem");
        1018                 :     }
        1019                 :
        1020                 :     Shmem::id_t aId;
        1021               0 :     if ((!(AdoptSharedMemory(rawmem, (&(aId)))))) {
        1022               0 :         return false;
        1023                 :     }
        1024                 :
        1025               0 :     (*(aOutMem)) = Shmem(Shmem::IHadBetterBeIPDLCodeCallingThis_OtherwiseIAmADoodyhead(), rawmem, aId);
        1026               0 :     return true;
        1027                 : }
        1028                 :
        1029                 : bool
        1030               0 : PSmsChild::DeallocShmem(Shmem& aMem)
        1031                 : {
        1032               0 :     bool ok = DestroySharedMemory(aMem);
        1033               0 :     (aMem).forget(Shmem::IHadBetterBeIPDLCodeCallingThis_OtherwiseIAmADoodyhead());
        1034               0 :     return ok;
        1035                 : }
        1036                 :
        1037                 : void
        1038               0 : PSmsChild::FatalError(const char* const msg) const
        1039                 : {
        1040                 :     // Virtual method to prevent inlining.
        1041                 :     // This give us better error reporting.
        1042                 :     // See bug 589371
        1043                 :
        1044               0 :     NS_ERROR("IPDL error:");
        1045               0 :     NS_ERROR(msg);
        1046                 :
        1047               0 :     NS_RUNTIMEABORT("[PSmsChild] abort()ing as a result");
        1048               0 : }
        1049                 :
        1050                 : void
        1051               0 : PSmsChild::DestroySubtree(ActorDestroyReason why)
        1052                 : {
        1053                 :     // Unregister from our manager.
        1054               0 :     Unregister(mId);
        1055               0 :     mId = 1;
        1056                 :
        1057                 :     // Finally, destroy "us".
        1058               0 :     ActorDestroy(why);
        1059               0 : }
        1060                 :
        1061                 : void
        1062               0 : PSmsChild::DeallocSubtree()
        1063                 : {
        1064               0 : }
        1065                 :
        1066                 : void
        1067               0 : PSmsChild::Write(
        1068                 :         const SmsMessageData& __v,
        1069                 :         Message* __msg)
        1070                 : {
        1071               0 :     Write((__v).id(), __msg);
        1072               0 :     Write((__v).delivery(), __msg);
        1073               0 :     Write((__v).sender(), __msg);
        1074               0 :     Write((__v).receiver(), __msg);
        1075               0 :     Write((__v).body(), __msg);
        1076               0 :     Write((__v).timestamp(), __msg);
        1077               0 : }
        1078                 :
        1079                 : bool
        1080               0 : PSmsChild::Read(
        1081                 :         SmsMessageData* __v,
        1082                 :         const Message* __msg,
        1083                 :         void** __iter)
        1084                 : {
        1085               0 :     if ((!(Read((&((__v)->id())), __msg, __iter)))) {
        1086               0 :         return false;
        1087                 :     }
        1088               0 :     if ((!(Read((&((__v)->delivery())), __msg, __iter)))) {
        1089               0 :         return false;
        1090                 :     }
        1091               0 :     if ((!(Read((&((__v)->sender())), __msg, __iter)))) {
        1092               0 :         return false;
        1093                 :     }
        1094               0 :     if ((!(Read((&((__v)->receiver())), __msg, __iter)))) {
        1095               0 :         return false;
        1096                 :     }
        1097               0 :     if ((!(Read((&((__v)->body())), __msg, __iter)))) {
        1098               0 :         return false;
        1099                 :     }
        1100               0 :     if ((!(Read((&((__v)->timestamp())), __msg, __iter)))) {
        1101               0 :         return false;
        1102                 :     }
        1103               0 :     return true;
        1104                 : }
        1105                 :
        1106                 : void
        1107               0 : PSmsChild::Write(
        1108                 :         const SmsFilterData& __v,
        1109                 :         Message* __msg)
        1110                 : {
        1111               0 :     Write((__v).startDate(), __msg);
        1112               0 :     Write((__v).endDate(), __msg);
        1113               0 :     Write((__v).numbers(), __msg);
        1114               0 :     Write((__v).delivery(), __msg);
        1115               0 : }
        1116                 :
        1117                 : bool
        1118               0 : PSmsChild::Read(
        1119                 :         SmsFilterData* __v,
        1120                 :         const Message* __msg,
        1121                 :         void** __iter)
        1122                 : {
        1123               0 :     if ((!(Read((&((__v)->startDate())), __msg, __iter)))) {
        1124               0 :         return false;
        1125                 :     }
        1126               0 :     if ((!(Read((&((__v)->endDate())), __msg, __iter)))) {
        1127               0 :         return false;
        1128                 :     }
        1129               0 :     if ((!(Read((&((__v)->numbers())), __msg, __iter)))) {
        1130               0 :         return false;
        1131                 :     }
        1132               0 :     if ((!(Read((&((__v)->delivery())), __msg, __iter)))) {
        1133               0 :         return false;
        1134                 :     }
        1135               0 :     return true;
        1136                 : }
        1137                 :
        1138                 : void
        1139               0 : PSmsChild::Write(
        1140                 :         PSmsChild* __v,
        1141                 :         Message* __msg,
        1142                 :         bool __nullable)
        1143                 : {
        1144                 :     int32 id;
        1145               0 :     if ((!(__v))) {
        1146               0 :         if ((!(__nullable))) {
        1147               0 :             NS_RUNTIMEABORT("NULL actor value passed to non-nullable param");
        1148                 :         }
        1149               0 :         id = 0;
        1150                 :     }
        1151                 :     else {
        1152               0 :         id = (__v)->mId;
        1153               0 :         if ((1) == (id)) {
        1154               0 :             NS_RUNTIMEABORT("actor has been |delete|d");
        1155                 :         }
        1156                 :     }
        1157                 :
        1158               0 :     Write(id, __msg);
        1159               0 : }
        1160                 :
        1161                 : bool
        1162               0 : PSmsChild::Read(
        1163                 :         PSmsChild** __v,
        1164                 :         const Message* __msg,
        1165                 :         void** __iter,
        1166                 :         bool __nullable)
        1167                 : {
        1168                 :     int32 id;
        1169               0 :     if ((!(Read((&(id)), __msg, __iter)))) {
        1170               0 :         return false;
        1171                 :     }
        1172               0 :     if (((1) == (id)) || (((0) == (id)) && ((!(__nullable))))) {
        1173               0 :         return false;
        1174                 :     }
        1175                 :
        1176               0 :     if ((0) == (id)) {
        1177               0 :         (*(__v)) = 0;
        1178                 :     }
        1179                 :     else {
        1180               0 :         (*(__v)) = static_cast<PSmsChild*>(Lookup(id));
        1181               0 :         if ((!((*(__v))))) {
        1182               0 :             return false;
        1183                 :         }
        1184                 :     }
        1185               0 :     return true;
        1186                 : }
        1187                 :
        1188                 :
        1189                 :
        1190                 : } // namespace sms
        1191                 : } // namespace dom
        1192                 : } // namespace mozilla

Generated by: LCOV version 1.7