VirtualBox

Changeset 45568 in vbox


Ignore:
Timestamp:
Apr 16, 2013 12:26:50 PM (12 years ago)
Author:
vboxsync
svn:sync-xref-src-repo-rev:
85059
Message:

Main/GuestCtrl: Removed dead code.

Location:
trunk/src/VBox/Main
Files:
3 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/VBox/Main/include/GuestCtrlImplPrivate.h

    r45415 r45568  
    4646class GuestProcessStreamBlock;
    4747class GuestSession;
    48 
    49 
    50 /**
    51  * Base class for a all guest control callbacks/events.
    52  */
    53 class GuestCtrlEvent
    54 {
    55 public:
    56 
    57     GuestCtrlEvent(void);
    58 
    59     virtual ~GuestCtrlEvent(void);
    60 
    61     /** @todo Copy/comparison operator? */
    62 
    63 public:
    64 
    65     int Cancel(void);
    66 
    67     bool Canceled(void);
    68 
    69     virtual void Destroy(void);
    70 
    71     int Init(void);
    72 
    73     virtual int Signal(int rc = VINF_SUCCESS);
    74 
    75     int GetResultCode(void) { return mRC; }
    76 
    77     int Wait(ULONG uTimeoutMS);
    78 
    79 protected:
    80 
    81     /** Was the callback canceled? */
    82     bool                        fCanceled;
    83     /** Did the callback complete? */
    84     bool                        fCompleted;
    85     /** The event semaphore for triggering
    86      *  the actual event. */
    87     RTSEMEVENT                  hEventSem;
    88     /** The waiting mutex. */
    89     RTSEMMUTEX                  hEventMutex;
    90     /** Overall result code. */
    91     int                         mRC;
    92 };
    93 
    94 
    95 /*
    96  * Enumeration holding the host callback types.
    97  */
    98 enum CALLBACKTYPE
    99 {
    100     CALLBACKTYPE_UNKNOWN = 0,
    101     /** Guest session status. */
    102     CALLBACKTYPE_SESSION_NOTIFY = 10,
    103     /** Guest process status. */
    104     CALLBACKTYPE_PROC_STATUS = 100,
    105     /** Guest process output notification. */
    106     CALLBACKTYPE_PROC_OUTPUT = 105,
    107     /** Guest process input notification. */
    108     CALLBACKTYPE_PROC_INPUT = 106,
    109     /** Guest file notification. */
    110     CALLBACKTYPE_FILE_NOTIFY = 210
    111 };
    112 
    113 
    114 /*
    115  * Class representing a guest control callback.
    116  */
    117 class GuestCtrlCallback : public GuestCtrlEvent
    118 {
    119 
    120 public:
    121 
    122     GuestCtrlCallback(void);
    123 
    124     GuestCtrlCallback(CALLBACKTYPE enmType);
    125 
    126     virtual ~GuestCtrlCallback(void);
    127 
    128 public:
    129 
    130     void Destroy(void);
    131 
    132     int Init(CALLBACKTYPE enmType);
    133 
    134     CALLBACKTYPE GetType(void) { return mType; }
    135 
    136     const void* GetDataRaw(void) const { return pvData; }
    137 
    138     size_t GetDataSize(void) { return cbData; }
    139 
    140     const void* GetPayloadRaw(void) const { return pvPayload; }
    141 
    142     size_t GetPayloadSize(void) { return cbPayload; }
    143 
    144     int SetData(const void *pvCallback, size_t cbCallback);
    145 
    146     int SetPayload(const void *pvToWrite, size_t cbToWrite);
    147 
    148 protected:
    149 
    150     /** Pointer to actual callback data. */
    151     void                       *pvData;
    152     /** Size of user-supplied data. */
    153     size_t                      cbData;
    154     /** The callback type. */
    155     CALLBACKTYPE                mType;
    156     /** Callback flags. */
    157     uint32_t                    uFlags;
    158     /** Payload which will be available on successful
    159      *  waiting (optional). */
    160     void                       *pvPayload;
    161     /** Size of the payload (optional). */
    162     size_t                      cbPayload;
    163 };
    164 typedef std::map < uint32_t, GuestCtrlCallback* > GuestCtrlCallbacks;
    165 
    166 
    167 /*
    168  * Class representing a guest control process waiting
    169  * event.
    170  */
    171 class GuestProcessWaitEvent : public GuestCtrlEvent
    172 {
    173 public:
    174 
    175     GuestProcessWaitEvent(void);
    176 
    177     GuestProcessWaitEvent(uint32_t uWaitFlags);
    178 
    179     virtual ~GuestProcessWaitEvent(void);
    180 
    181 public:
    182 
    183     void Destroy(void);
    184 
    185     int Init(uint32_t uWaitFlags);
    186 
    187     uint32_t GetWaitFlags(void) { return ASMAtomicReadU32(&mFlags); }
    188 
    189     ProcessWaitResult_T GetWaitResult(void) { return mResult; }
    190 
    191     int GetWaitRc(void) { return mRC; }
    192 
    193     int Signal(ProcessWaitResult_T enmResult, int rc = VINF_SUCCESS);
    194 
    195 protected:
    196 
    197     /** The waiting flag(s). The specifies what to
    198      *  wait for. See ProcessWaitFlag_T. */
    199     uint32_t                    mFlags;
    200     /** Structure containing the overall result. */
    201     ProcessWaitResult_T         mResult;
    202 };
    203 
    204 
    205 /*
    206  * Class representing a guest control session waiting
    207  * event.
    208  */
    209 class GuestSessionWaitEvent : public GuestCtrlEvent
    210 {
    211 public:
    212 
    213     GuestSessionWaitEvent(void);
    214 
    215     GuestSessionWaitEvent(uint32_t uWaitFlags);
    216 
    217     virtual ~GuestSessionWaitEvent(void);
    218 
    219 public:
    220 
    221     void Destroy(void);
    222 
    223     int Init(uint32_t uWaitFlags);
    224 
    225     uint32_t GetWaitFlags(void) { return ASMAtomicReadU32(&mFlags); }
    226 
    227     GuestSessionWaitResult_T GetWaitResult(void) { return mResult; }
    228 
    229     int GetWaitRc(void) { return mRC; }
    230 
    231     int Signal(GuestSessionWaitResult_T enmResult, int rc = VINF_SUCCESS);
    232 
    233 protected:
    234 
    235     /** The waiting flag(s). The specifies what to
    236      *  wait for. See GuestSessionWaitFlag_T. */
    237     uint32_t                    mFlags;
    238     /** Structure containing the overall result. */
    239     GuestSessionWaitResult_T    mResult;
    240 };
    24148
    24249

  • trunk/src/VBox/Main/include/GuestFileImpl.h

    r45434 r45568  
    116116    struct Data
    117117    {
    118         /** All related callbacks to this file. */
    119         GuestCtrlCallbacks      mCallbacks;
    120118        /** The file's open info. */
    121119        GuestFileOpenInfo       mOpenInfo;

  • trunk/src/VBox/Main/src-client/GuestCtrlPrivate.cpp

    r45415 r45568  
    3939 *   Structures and Typedefs                                                  *
    4040 ******************************************************************************/
    41 
    42 GuestCtrlEvent::GuestCtrlEvent(void)
    43     : fCanceled(false),
    44       fCompleted(false),
    45       hEventSem(NIL_RTSEMEVENT),
    46       mRC(VINF_SUCCESS)
    47 {
    48 }
    49 
    50 GuestCtrlEvent::~GuestCtrlEvent(void)
    51 {
    52     Destroy();
    53 }
    54 
    55 int GuestCtrlEvent::Cancel(void)
    56 {
    57     int rc = VINF_SUCCESS;
    58     if (!ASMAtomicReadBool(&fCompleted))
    59     {
    60         if (!ASMAtomicReadBool(&fCanceled))
    61         {
    62             ASMAtomicXchgBool(&fCanceled, true);
    63 
    64             LogFlowThisFunc(("Cancelling event ...\n"));
    65             rc = hEventSem != NIL_RTSEMEVENT
    66                ? RTSemEventSignal(hEventSem) : VINF_SUCCESS;
    67         }
    68     }
    69 
    70     return rc;
    71 }
    72 
    73 bool GuestCtrlEvent::Canceled(void)
    74 {
    75     return ASMAtomicReadBool(&fCanceled);
    76 }
    77 
    78 void GuestCtrlEvent::Destroy(void)
    79 {
    80     int rc = Cancel();
    81     AssertRC(rc);
    82 
    83     if (hEventSem != NIL_RTSEMEVENT)
    84     {
    85         RTSemEventDestroy(hEventSem);
    86         hEventSem = NIL_RTSEMEVENT;
    87     }
    88 }
    89 
    90 int GuestCtrlEvent::Init(void)
    91 {
    92     return RTSemEventCreate(&hEventSem);
    93 }
    94 
    95 int GuestCtrlEvent::Signal(int rc /*= VINF_SUCCESS*/)
    96 {
    97     AssertReturn(hEventSem != NIL_RTSEMEVENT, VERR_CANCELLED);
    98 
    99     mRC = rc;
    100 
    101     return RTSemEventSignal(hEventSem);
    102 }
    103 
    104 int GuestCtrlEvent::Wait(ULONG uTimeoutMS)
    105 {
    106     LogFlowThisFuncEnter();
    107 
    108     AssertReturn(hEventSem != NIL_RTSEMEVENT, VERR_CANCELLED);
    109 
    110     RTMSINTERVAL msInterval = uTimeoutMS;
    111     if (!uTimeoutMS)
    112         msInterval = RT_INDEFINITE_WAIT;
    113     int rc = RTSemEventWait(hEventSem, msInterval);
    114     if (RT_SUCCESS(rc))
    115         ASMAtomicWriteBool(&fCompleted, true);
    116 
    117     LogFlowFuncLeaveRC(rc);
    118     return rc;
    119 }
    120 
    121 ///////////////////////////////////////////////////////////////////////////////
    122 
    123 GuestCtrlCallback::GuestCtrlCallback(void)
    124     : pvData(NULL),
    125       cbData(0),
    126       mType(CALLBACKTYPE_UNKNOWN),
    127       uFlags(0),
    128       pvPayload(NULL),
    129       cbPayload(0)
    130 {
    131 }
    132 
    133 GuestCtrlCallback::GuestCtrlCallback(CALLBACKTYPE enmType)
    134     : pvData(NULL),
    135       cbData(0),
    136       mType(CALLBACKTYPE_UNKNOWN),
    137       uFlags(0),
    138       pvPayload(NULL),
    139       cbPayload(0)
    140 {
    141     int rc = Init(enmType);
    142     AssertRC(rc);
    143 }
    144 
    145 GuestCtrlCallback::~GuestCtrlCallback(void)
    146 {
    147     Destroy();
    148 }
    149 
    150 int GuestCtrlCallback::Init(CALLBACKTYPE enmType)
    151 {
    152     AssertReturn(enmType > CALLBACKTYPE_UNKNOWN, VERR_INVALID_PARAMETER);
    153     Assert((pvData == NULL) && !cbData);
    154 
    155     int rc = VINF_SUCCESS;
    156 
    157     switch (enmType)
    158     {
    159         case CALLBACKTYPE_SESSION_NOTIFY:
    160         {
    161             pvData = (PCALLBACKDATA_SESSION_NOTIFY)RTMemAllocZ(sizeof(CALLBACKDATA_SESSION_NOTIFY));
    162             AssertPtrReturn(pvData, VERR_NO_MEMORY);
    163             cbData = sizeof(CALLBACKDATA_SESSION_NOTIFY);
    164             break;
    165         }
    166 
    167         case CALLBACKTYPE_PROC_STATUS:
    168         {
    169             pvData = (PCALLBACKDATA_PROC_STATUS)RTMemAllocZ(sizeof(CALLBACKDATA_PROC_STATUS));
    170             AssertPtrReturn(pvData, VERR_NO_MEMORY);
    171             cbData = sizeof(CALLBACKDATA_PROC_STATUS);
    172             break;
    173         }
    174 
    175         case CALLBACKTYPE_PROC_OUTPUT:
    176         {
    177             pvData = (PCALLBACKDATA_PROC_OUTPUT)RTMemAllocZ(sizeof(CALLBACKDATA_PROC_OUTPUT));
    178             AssertPtrReturn(pvData, VERR_NO_MEMORY);
    179             cbData = sizeof(CALLBACKDATA_PROC_OUTPUT);
    180             break;
    181         }
    182 
    183         case CALLBACKTYPE_PROC_INPUT:
    184         {
    185             pvData = (PCALLBACKDATA_PROC_INPUT)RTMemAllocZ(sizeof(CALLBACKDATA_PROC_INPUT));
    186             AssertPtrReturn(pvData, VERR_NO_MEMORY);
    187             cbData = sizeof(CALLBACKDATA_PROC_INPUT);
    188             break;
    189         }
    190 
    191         case CALLBACKTYPE_FILE_NOTIFY:
    192         {
    193             pvData = (PCALLBACKDATA_FILE_NOTIFY)RTMemAllocZ(sizeof(CALLBACKDATA_FILE_NOTIFY));
    194             AssertPtrReturn(pvData, VERR_NO_MEMORY);
    195             cbData = sizeof(CALLBACKDATA_FILE_NOTIFY);
    196             break;
    197         }
    198 
    199         default:
    200             AssertMsgFailed(("Unknown callback type specified (%ld)\n", enmType));
    201             rc = VERR_NOT_IMPLEMENTED;
    202             break;
    203     }
    204 
    205     if (RT_SUCCESS(rc))
    206     {
    207         rc = GuestCtrlEvent::Init();
    208         if (RT_SUCCESS(rc))
    209             mType  = enmType;
    210     }
    211 
    212     return rc;
    213 }
    214 
    215 void GuestCtrlCallback::Destroy(void)
    216 {
    217     GuestCtrlEvent::Destroy();
    218 
    219     switch (mType)
    220     {
    221         case CALLBACKTYPE_PROC_OUTPUT:
    222         {
    223             PCALLBACKDATA_PROC_OUTPUT pThis = (PCALLBACKDATA_PROC_OUTPUT)pvData;
    224             AssertPtr(pThis);
    225             if (pThis->pvData)
    226                 RTMemFree(pThis->pvData);
    227             break;
    228         }
    229 
    230         case CALLBACKTYPE_FILE_NOTIFY:
    231         {
    232             PCALLBACKDATA_FILE_NOTIFY pThis = (PCALLBACKDATA_FILE_NOTIFY)pvData;
    233             AssertPtr(pThis);
    234             switch (pThis->uType)
    235             {
    236                 case GUEST_FILE_NOTIFYTYPE_READ:
    237                 {
    238                     if (pThis->u.read.pvData)
    239                     {
    240                         RTMemFree(pThis->u.read.pvData);
    241                         pThis->u.read.pvData = NULL;
    242                     }
    243 
    244                     break;
    245                 }
    246 
    247                 default:
    248                     break;
    249             }
    250         }
    251 
    252         default:
    253            break;
    254     }
    255 
    256     mType = CALLBACKTYPE_UNKNOWN;
    257     if (pvData)
    258     {
    259         RTMemFree(pvData);
    260         pvData = NULL;
    261     }
    262     cbData = 0;
    263 
    264     if (pvPayload)
    265     {
    266         RTMemFree(pvPayload);
    267         pvPayload = NULL;
    268     }
    269     cbPayload = 0;
    270 }
    271 
    272 int GuestCtrlCallback::SetData(const void *pvCallback, size_t cbCallback)
    273 {
    274     if (!cbCallback)
    275         return VINF_SUCCESS;
    276     AssertPtr(pvCallback);
    277 
    278     int rc = VINF_SUCCESS;
    279     switch (mType)
    280     {
    281         case CALLBACKTYPE_SESSION_NOTIFY:
    282         {
    283             PCALLBACKDATA_SESSION_NOTIFY pThis = (PCALLBACKDATA_SESSION_NOTIFY)pvData;
    284             PCALLBACKDATA_SESSION_NOTIFY pCB   = (PCALLBACKDATA_SESSION_NOTIFY)pvCallback;
    285             Assert(cbCallback == sizeof(CALLBACKDATA_SESSION_NOTIFY));
    286 
    287             memcpy(pThis, pCB, sizeof(CALLBACKDATA_SESSION_NOTIFY));
    288             break;
    289         }
    290 
    291         case CALLBACKTYPE_PROC_STATUS:
    292         {
    293             PCALLBACKDATA_PROC_STATUS pThis = (PCALLBACKDATA_PROC_STATUS)pvData;
    294             PCALLBACKDATA_PROC_STATUS pCB   = (PCALLBACKDATA_PROC_STATUS)pvCallback;
    295             Assert(cbCallback == sizeof(CALLBACKDATA_PROC_STATUS));
    296 
    297             memcpy(pThis, pCB, sizeof(CALLBACKDATA_PROC_STATUS));
    298             break;
    299         }
    300 
    301         case CALLBACKTYPE_PROC_OUTPUT:
    302         {
    303             PCALLBACKDATA_PROC_OUTPUT pThis = (PCALLBACKDATA_PROC_OUTPUT)pvData;
    304             PCALLBACKDATA_PROC_OUTPUT pCB   = (PCALLBACKDATA_PROC_OUTPUT)pvCallback;
    305             Assert(cbCallback == sizeof(CALLBACKDATA_PROC_OUTPUT));
    306 
    307             if (pCB->cbData)
    308             {
    309                 pThis->pvData   = RTMemAlloc(pCB->cbData);
    310                 AssertPtrReturn(pThis->pvData, VERR_NO_MEMORY);
    311                 memcpy(pThis->pvData, pCB->pvData, pCB->cbData);
    312                 pThis->cbData   = pCB->cbData;
    313             }
    314             pThis->uFlags = pCB->uFlags;
    315             pThis->uPID   = pCB->uPID;
    316             break;
    317         }
    318 
    319         case CALLBACKTYPE_PROC_INPUT:
    320         {
    321             PCALLBACKDATA_PROC_INPUT pThis = (PCALLBACKDATA_PROC_INPUT)pvData;
    322             PCALLBACKDATA_PROC_INPUT pCB   = (PCALLBACKDATA_PROC_INPUT)pvCallback;
    323             Assert(cbCallback == sizeof(CALLBACKDATA_PROC_INPUT));
    324 
    325             memcpy(pThis, pCB, sizeof(CALLBACKDATA_PROC_INPUT));
    326             break;
    327         }
    328 
    329         case CALLBACKTYPE_FILE_NOTIFY:
    330         {
    331             PCALLBACKDATA_FILE_NOTIFY pThis = (PCALLBACKDATA_FILE_NOTIFY)pvData;
    332             PCALLBACKDATA_FILE_NOTIFY pCB = (PCALLBACKDATA_FILE_NOTIFY)pvCallback;
    333             Assert(cbCallback == sizeof(CALLBACKDATA_FILE_NOTIFY));
    334 
    335             memcpy(pThis, pCB, sizeof(CALLBACKDATA_FILE_NOTIFY));
    336 
    337             switch (pThis->uType)
    338             {
    339                 case GUEST_FILE_NOTIFYTYPE_READ:
    340                 {
    341                     pThis->u.read.pvData   = RTMemAlloc(pCB->u.read.cbData);
    342                     AssertPtrReturn(pThis->u.read.pvData, VERR_NO_MEMORY);
    343                     memcpy(pThis->u.read.pvData, pCB->u.read.pvData, pCB->u.read.cbData);
    344                     pThis->u.read.cbData   = pCB->u.read.cbData;
    345                     break;
    346                 }
    347 
    348                 default:
    349                     break;
    350             }
    351             break;
    352         }
    353 
    354 #if 0
    355         case CALLBACKTYPE_FILE_OPEN:
    356         {
    357             PCALLBACKPAYLOAD_FILE_NOTIFY_OPEN pThis = (PCALLBACKPAYLOAD_FILE_NOTIFY_OPEN)pvData;
    358             PCALLBACKPAYLOAD_FILE_NOTIFY_OPEN pCB   = (PCALLBACKPAYLOAD_FILE_NOTIFY_OPEN)pvCallback;
    359             Assert(cbCallback == sizeof(CALLBACKPAYLOAD_FILE_NOTIFY_OPEN));
    360 
    361             pThis->rc = pCB->rc;
    362             pThis->uHandle = pCB->uHandle;
    363             break;
    364         }
    365 
    366         case CALLBACKTYPE_FILE_CLOSE:
    367         {
    368             PCALLBACKPAYLOAD_FILE_NOTIFY_CLOSE pThis = (PCALLBACKPAYLOAD_FILE_NOTIFY_CLOSE)pvData;
    369             PCALLBACKPAYLOAD_FILE_NOTIFY_CLOSE pCB   = (PCALLBACKPAYLOAD_FILE_NOTIFY_CLOSE)pvCallback;
    370             Assert(cbCallback == sizeof(CALLBACKPAYLOAD_FILE_NOTIFY_CLOSE));
    371 
    372             pThis->rc = pCB->rc;
    373             break;
    374         }
    375 
    376         case CALLBACKTYPE_FILE_READ:
    377         {
    378             PCALLBACKPAYLOAD_FILE_NOTIFY_READ pThis = (PCALLBACKPAYLOAD_FILE_NOTIFY_READ)pvData;
    379             PCALLBACKPAYLOAD_FILE_NOTIFY_READ pCB   = (PCALLBACKPAYLOAD_FILE_NOTIFY_READ)pvCallback;
    380             Assert(cbCallback == sizeof(CALLBACKPAYLOAD_FILE_NOTIFY_READ));
    381 
    382             pThis->rc = pCB->rc;
    383             if (pCB->cbData)
    384             {
    385                 pThis->pvData   = RTMemAlloc(pCB->cbData);
    386                 AssertPtrReturn(pThis->pvData, VERR_NO_MEMORY);
    387                 memcpy(pThis->pvData, pCB->pvData, pCB->cbData);
    388                 pThis->cbData   = pCB->cbData;
    389             }
    390             break;
    391         }
    392 
    393         case CALLBACKTYPE_FILE_WRITE:
    394         {
    395             PCALLBACKPAYLOAD_FILE_NOTIFY_WRITE pThis = (PCALLBACKPAYLOAD_FILE_NOTIFY_WRITE)pvData;
    396             PCALLBACKPAYLOAD_FILE_NOTIFY_WRITE pCB   = (PCALLBACKPAYLOAD_FILE_NOTIFY_WRITE)pvCallback;
    397             Assert(cbCallback == sizeof(CALLBACKPAYLOAD_FILE_NOTIFY_WRITE));
    398 
    399             pThis->rc = pCB->rc;
    400             pThis->cbWritten = pCB->cbWritten;
    401             break;
    402         }
    403 
    404         case CALLBACKTYPE_FILE_SEEK:
    405         {
    406             PCALLBACKPAYLOAD_FILE_NOTIFY_SEEK pThis = (PCALLBACKPAYLOAD_FILE_NOTIFY_SEEK)pvData;
    407             PCALLBACKPAYLOAD_FILE_NOTIFY_SEEK pCB   = (PCALLBACKPAYLOAD_FILE_NOTIFY_SEEK)pvCallback;
    408             Assert(cbCallback == sizeof(CALLBACKPAYLOAD_FILE_NOTFIY_SEEK));
    409 
    410             pThis->rc = pCB->rc;
    411             pThis->uOffActual = pCB->uOffActual;
    412             break;
    413         }
    414 
    415         case CALLBACKTYPE_FILE_TELL:
    416         {
    417             PCALLBACKPAYLOAD_FILE_NOTIFY_TELL pThis = (PCALLBACKPAYLOAD_FILE_NOTIFY_TELL)pvData;
    418             PCALLBACKPAYLOAD_FILE_NOTIFY_TELL pCB   = (PCALLBACKPAYLOAD_FILE_NOTIFY_TELL)pvCallback;
    419             Assert(cbCallback == sizeof(CALLBACKPAYLOAD_FILE_NOTFIY_TELL));
    420 
    421             pThis->rc = pCB->rc;
    422             pThis->uOffActual = pCB->uOffActual;
    423             break;
    424         }
    425 #endif
    426         default:
    427             AssertMsgFailed(("Callback type not supported (%ld)\n", mType));
    428             rc = VERR_NOT_SUPPORTED;
    429             break;
    430     }
    431 
    432     return rc;
    433 }
    434 
    435 int GuestCtrlCallback::SetPayload(const void *pvToWrite, size_t cbToWrite)
    436 {
    437     if (!cbToWrite)
    438         return VINF_SUCCESS;
    439     AssertPtr(pvToWrite);
    440 
    441     Assert(pvPayload == NULL); /* Can't reuse callbacks! */
    442     pvPayload = RTMemAlloc(cbToWrite);
    443     if (!pvPayload)
    444         return VERR_NO_MEMORY;
    445 
    446     memcpy(pvPayload, pvToWrite, cbToWrite);
    447     cbPayload = cbToWrite;
    448 
    449     return VINF_SUCCESS;
    450 }
    451 
    452 ///////////////////////////////////////////////////////////////////////////////
    453 
    454 GuestProcessWaitEvent::GuestProcessWaitEvent(void)
    455     : mFlags(0),
    456       mResult(ProcessWaitResult_None)
    457 {
    458 }
    459 
    460 GuestProcessWaitEvent::GuestProcessWaitEvent(uint32_t uWaitFlags)
    461     : mFlags(uWaitFlags)
    462 {
    463     int rc = GuestCtrlEvent::Init();
    464     AssertRC(rc);
    465 }
    466 
    467 GuestProcessWaitEvent::~GuestProcessWaitEvent(void)
    468 {
    469     Destroy();
    470 }
    471 
    472 void GuestProcessWaitEvent::Destroy(void)
    473 {
    474     GuestCtrlEvent::Destroy();
    475 
    476     mFlags = ProcessWaitForFlag_None;
    477 }
    478 
    479 int GuestProcessWaitEvent::Signal(ProcessWaitResult_T enmResult, int rc /*= VINF_SUCCESS*/)
    480 {
    481     mResult = enmResult;
    482 
    483     return GuestCtrlEvent::Signal(rc);
    484 }
    485 
    486 ///////////////////////////////////////////////////////////////////////////////
    487 
    488 GuestSessionWaitEvent::GuestSessionWaitEvent(void)
    489     : mFlags(0),
    490       mResult(GuestSessionWaitResult_None)
    491 {
    492 }
    493 
    494 GuestSessionWaitEvent::GuestSessionWaitEvent(uint32_t uWaitFlags)
    495     : mFlags(uWaitFlags)
    496 {
    497     int rc = GuestCtrlEvent::Init();
    498     AssertRC(rc);
    499 }
    500 
    501 GuestSessionWaitEvent::~GuestSessionWaitEvent(void)
    502 {
    503     Destroy();
    504 }
    505 
    506 void GuestSessionWaitEvent::Destroy(void)
    507 {
    508     GuestCtrlEvent::Destroy();
    509 
    510     mFlags = GuestSessionWaitForFlag_None;
    511 }
    512 
    513 int GuestSessionWaitEvent::Signal(GuestSessionWaitResult_T enmResult, int rc /*= VINF_SUCCESS*/)
    514 {
    515     mResult = enmResult;
    516 
    517     return GuestCtrlEvent::Signal(rc);
    518 }
    519 
    520 ///////////////////////////////////////////////////////////////////////////////
    52141
    52242int GuestEnvironment::BuildEnvironmentBlock(void **ppvEnv, size_t *pcbEnv, uint32_t *pcEnvVars)
Note: See TracChangeset for help on using the changeset viewer.

© 2025 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette