自学教程：C++ AssertPtr函数代码示例

RTDECL(bool) RTManifestEntryExists(RTMANIFEST hManifest, const char *pszEntry){    RTMANIFESTINT *pThis = hManifest;    AssertPtrReturn(pThis, false);    AssertReturn(pThis->u32Magic == RTMANIFEST_MAGIC, false);    AssertPtr(pszEntry);    bool    fNeedNormalization;    size_t  cchEntry;    int rc = rtManifestValidateNameEntry(pszEntry, &fNeedNormalization, &cchEntry);    AssertRCReturn(rc, false);    /*     * Check if it exists.     */    PRTMANIFESTENTRY pEntry;    rc = rtManifestGetEntry(pThis, pszEntry, fNeedNormalization, cchEntry, &pEntry);    return RT_SUCCESS_NP(rc);}

DECLCALLBACK(int) VBoxClipboardInit(const PVBOXSERVICEENV pEnv, void **ppInstance){    LogFlowFuncEnter();    PVBOXCLIPBOARDCONTEXT pCtx = &g_Ctx; /* Only one instance for now. */    AssertPtr(pCtx);    if (pCtx->pEnv)    {        /* Clipboard was already initialized. 2 or more instances are not supported. */        return VERR_NOT_SUPPORTED;    }    if (VbglR3AutoLogonIsRemoteSession())    {        /* Do not use clipboard for remote sessions. */        LogRel(("Clipboard: Clipboard has been disabled for a remote session/n"));        return VERR_NOT_SUPPORTED;    }    RT_BZERO(pCtx, sizeof(VBOXCLIPBOARDCONTEXT));    pCtx->pEnv = pEnv;    /* Check that new Clipboard API is available */    vboxClipboardInitNewAPI(pCtx);    int rc = VbglR3ClipboardConnect(&pCtx->u32ClientID);    if (RT_SUCCESS(rc))    {        rc = vboxClipboardCreateWindow(pCtx);        if (RT_SUCCESS(rc))        {            *ppInstance = pCtx;        }        else        {            VbglR3ClipboardDisconnect(pCtx->u32ClientID);        }    }    LogFlowFuncLeaveRC(rc);    return rc;}

/** * Logs a verbose message. * * @param   pszFormat   The message text. * @param   va          Format arguments. */void VGSvcLogV(const char *pszFormat, va_list va){#ifdef DEBUG    int rc = RTCritSectEnter(&g_csLog);    if (RT_SUCCESS(rc))    {#endif        char *psz = NULL;        RTStrAPrintfV(&psz, pszFormat, va);        AssertPtr(psz);        LogRel(("%s", psz));        RTStrFree(psz);#ifdef DEBUG        RTCritSectLeave(&g_csLog);    }#endif}

RTDECL(void) RTSpinlockAcquire(RTSPINLOCK Spinlock){    PRTSPINLOCKINTERNAL pThis = (PRTSPINLOCKINTERNAL)Spinlock;    RT_ASSERT_PREEMPT_CPUID_VAR();    AssertPtr(pThis);    Assert(pThis->u32Magic == RTSPINLOCK_MAGIC);    if (pThis->fFlags & RTSPINLOCK_FLAGS_INTERRUPT_SAFE)    {#if defined(RT_ARCH_AMD64) || defined(RT_ARCH_X86)        uint32_t fIntSaved = ASMIntDisableFlags();#endif        mutex_enter(&pThis->Mtx);        /*         * Solaris 10 doesn't preserve the interrupt flag, but since we're at PIL_MAX we should be         * fine and not get interrupts while lock is held. Re-disable interrupts to not upset         * assertions & assumptions callers might have.         */#if defined(RT_ARCH_AMD64) || defined(RT_ARCH_X86)        ASMIntDisable();#endif#if defined(RT_ARCH_AMD64) || defined(RT_ARCH_X86)        Assert(!ASMIntAreEnabled());#endif        pThis->fIntSaved = fIntSaved;    }    else    {#if defined(RT_STRICT) && (defined(RT_ARCH_AMD64) || defined(RT_ARCH_X86))        bool fIntsOn = ASMIntAreEnabled();#endif        mutex_enter(&pThis->Mtx);#if defined(RT_ARCH_AMD64) || defined(RT_ARCH_X86)        AssertMsg(fIntsOn == ASMIntAreEnabled(), ("fIntsOn=%RTbool/n", fIntsOn));#endif    }    RT_ASSERT_PREEMPT_CPUID_SPIN_ACQUIRED(pThis);}

/** * Invokes the write-MSR handler for the GIM provider configured for the VM. * * @returns Strict VBox status code like CPUMSetGuestMsr. * @retval  VINF_CPUM_R3_MSR_WRITE * @retval  VERR_CPUM_RAISE_GP_0 * * @param   pVCpu       Pointer to the VMCPU. * @param   idMsr       The MSR to write. * @param   pRange      The range this MSR belongs to. * @param   uValue      The value to set, ignored bits masked. * @param   uRawValue   The raw value with the ignored bits not masked. */VMM_INT_DECL(VBOXSTRICTRC) GIMWriteMsr(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t uValue, uint64_t uRawValue){    AssertPtr(pVCpu);    NOREF(uValue);    PVM pVM = pVCpu->CTX_SUFF(pVM);    Assert(GIMIsEnabled(pVM));    VMCPU_ASSERT_EMT(pVCpu);    switch (pVM->gim.s.enmProviderId)    {        case GIMPROVIDERID_HYPERV:            return GIMHvWriteMsr(pVCpu, idMsr, pRange, uRawValue);        default:            AssertMsgFailed(("GIMWriteMsr: for unknown provider %u idMsr=%#RX32 -> #GP(0)", pVM->gim.s.enmProviderId, idMsr));            return VERR_CPUM_RAISE_GP_0;    }}

void VBoxSeamlessDestroy(void *pInstance){    LogFlowFuncEnter();    PVBOXSEAMLESSCONTEXT pCtx = (PVBOXSEAMLESSCONTEXT)pInstance;    AssertPtr(pCtx);    VBoxSeamlessSetSupported(FALSE);    /* Inform the host that we no longer support the seamless window mode. */    if (pCtx->pfnVBoxHookRemoveWindowTracker)        pCtx->pfnVBoxHookRemoveWindowTracker();    if (pCtx->hModHook != NIL_RTLDRMOD)    {        RTLdrClose(pCtx->hModHook);        pCtx->hModHook = NIL_RTLDRMOD;    }    return;}

/** * Internal worker for the RTMpOn* APIs using KeIpiGenericCall. * * @returns IPRT status code. * @param   pfnWorker       The callback. * @param   pvUser1         User argument 1. * @param   pvUser2         User argument 2. * @param   enmCpuid        What to do / is idCpu valid. * @param   idCpu           Used if enmCpuid RT_NT_CPUID_SPECIFIC, otherwise ignored. */static int rtMpCallUsingBroadcastIpi(PFNRTMPWORKER pfnWorker, void *pvUser1, void *pvUser2,                                     PKIPI_BROADCAST_WORKER pfnNativeWrapper, RTCPUID idCpu){    RTMPARGS Args;    Args.pfnWorker = pfnWorker;    Args.pvUser1   = pvUser1;    Args.pvUser2   = pvUser2;    Args.idCpu     = idCpu;    Args.cRefs     = 0;    Args.cHits     = 0;    AssertPtr(g_pfnrtKeIpiGenericCall);    g_pfnrtKeIpiGenericCall(pfnNativeWrapper, (uintptr_t)&Args);    if (   pfnNativeWrapper != rtmpNtOnSpecificBroadcastIpiWrapper        || Args.cHits > 0)        return VINF_SUCCESS;    return VERR_CPU_OFFLINE;}

bool DevAssetManager::ContainsAsset( const char* filePath ) const{	AssertPtr(filePath);	VRET_FALSE_IF_NIL(filePath);	String	fileName( filePath );	// check if the file is located in source assets folder and extract its name	{		const bool casesensitive = true;		const INT pos = String::FindText( filePath, m_pathToSrcAssets, casesensitive );		if( pos != INDEX_NONE )		{			// get file name relative to base folder			fileName.StripLeadingOnce( m_pathToSrcAssets );		}	}	return m_assetIDs.FindGuidByName( fileName ) != nil;}

/*----------------------------------------------------------------------------------------------	Open a key, which is the name of a Graphite font, and return a handle to it.	@param pszFontKey		- the name of the font	@param pszStyle			- regular, bold, italic, bolditalic;								ignored here--caller opens string value	@param at				- access	@param phkey			- handle to return----------------------------------------------------------------------------------------------*/bool GrUtil::OpenFontKey(const utf16 * pszFontKey, const utf16 * pszStyle,		AccessType at, HKEY * phkey){	AssertPsz((const wchar_t*)pszFontKey);	AssertPsz((const wchar_t*)pszStyle);	AssertPtr(phkey);//#ifdef GR_FW//	StrApp str;//	str.Format(_T("Software//SIL//GraphiteFonts//%s"), pszFontKey);//#else	OLECHAR str[260];	_stprintf_s(str, _T("Software//SIL//GraphiteFonts//%s"), (wchar_t*)pszFontKey);//#endif	if (at == katRead)		return ::RegOpenKeyEx(HKEY_LOCAL_MACHINE, str, 0, at, phkey) == ERROR_SUCCESS;	return ::RegCreateKeyEx(HKEY_LOCAL_MACHINE, str, 0, NULL, 0, at, NULL, phkey,		NULL) == ERROR_SUCCESS;}

/** * Checks if receive is possible and increases busy and ref counters if so. * * @param   pThis           The instance. */DECLHIDDEN(bool) vboxNetAdpPrepareToReceive(PVBOXNETADP pThis){    bool fCanReceive  = false;    /*     * Input validation.     */    AssertPtr(pThis);    Assert(pThis->MyPort.u32Version == INTNETTRUNKIFPORT_VERSION);    RTSpinlockAcquire(pThis->hSpinlock);    if (vboxNetAdpGetState(pThis) == kVBoxNetAdpState_Active)    {        fCanReceive = true;        vboxNetAdpRetain(pThis);        vboxNetAdpBusy(pThis);    }    RTSpinlockRelease(pThis->hSpinlock);    Log(("vboxNetAdpPrepareToReceive: fCanReceive=%d./n", fCanReceive));    return fCanReceive;}

/*----------------------------------------------------------------------------------------------	Get the empty string for this thread.----------------------------------------------------------------------------------------------*/void TextServGlobals::GetEmptyString(ITsString ** pptss){	AssertPtr(pptss);	Assert(!*pptss);	TextServGlobals * ptsg = GetTsGlobals();	if (!ptsg->m_qtssEmpty)	{		if (ptsg->m_cactActive <= 0)		{			Warn("Empty string requested with no active clients");			TsStrSingle::Create((OLECHAR *)NULL, 0, NULL, pptss);		}		TsStrSingle::Create((OLECHAR *)NULL, 0, NULL, &ptsg->m_qtssEmpty);	}	*pptss = ptsg->m_qtssEmpty;	AddRefObj(*pptss);}

RTDECL(int) RTThreadCtxHooksDeregister(RTTHREADCTX hThreadCtx){    /*     * Validate input.     */    PRTTHREADCTXINT pThis = hThreadCtx;    if (pThis == NIL_RTTHREADCTX)        return VERR_INVALID_HANDLE;    AssertPtr(pThis);    AssertMsgReturn(pThis->u32Magic == RTTHREADCTXINT_MAGIC, ("pThis->u32Magic=%RX32 pThis=%p/n", pThis->u32Magic, pThis),                    VERR_INVALID_HANDLE);    Assert(pThis->hOwner == RTThreadNativeSelf());    Assert(pThis->fRegistered);    /*     * Deregister the callback.     */    rtThreadCtxHooksDeregister(pThis);    return VINF_SUCCESS;}

/** * Reads a guest property as a 32-bit value. * * @returns VBox status code, fully bitched. * * @param   u32ClientId         The HGCM client ID for the guest property session. * @param   pszPropName         The property name. * @param   pu32                Where to store the 32-bit value. * */int VBoxServiceReadPropUInt32(uint32_t u32ClientId, const char *pszPropName, uint32_t *pu32, uint32_t u32Min, uint32_t u32Max){    char *pszValue;    int rc = VBoxServiceReadProp(u32ClientId, pszPropName, &pszValue,        NULL /* ppszFlags */, NULL /* puTimestamp */);    if (RT_SUCCESS(rc))    {        AssertPtr(pu32);        char *pszNext;        rc = RTStrToUInt32Ex(pszValue, &pszNext, 0, pu32);        if (   RT_SUCCESS(rc)            && (*pu32 < u32Min || *pu32 > u32Max))        {            rc = VBoxServiceError("The guest property value %s = %RU32 is out of range [%RU32..%RU32]./n",                                  pszPropName, *pu32, u32Min, u32Max);        }        RTStrFree(pszValue);    }    return rc;}

static void pdmNsBwGroupUnlink(PPDMNSBWGROUP pBwGroup){    PPDMNETSHAPER pShaper = pBwGroup->pShaper;    LOCK_NETSHAPER(pShaper);    if (pBwGroup == pShaper->pBwGroupsHead)        pShaper->pBwGroupsHead = pBwGroup->pNext;    else    {        PPDMNSBWGROUP pPrev = pShaper->pBwGroupsHead;        while (   pPrev               && pPrev->pNext != pBwGroup)            pPrev = pPrev->pNext;        AssertPtr(pPrev);        pPrev->pNext = pBwGroup->pNext;    }    UNLOCK_NETSHAPER(pShaper);}

static void pdmNsBwGroupUnlink(PPDMNSBWGROUP pBwGroup){    PPDMNETSHAPER pShaper = pBwGroup->pShaper;    int rc = RTCritSectEnter(&pShaper->cs); AssertRC(rc);    if (pBwGroup == pShaper->pBwGroupsHead)        pShaper->pBwGroupsHead = pBwGroup->pNext;    else    {        PPDMNSBWGROUP pPrev = pShaper->pBwGroupsHead;        while (   pPrev               && pPrev->pNext != pBwGroup)            pPrev = pPrev->pNext;        AssertPtr(pPrev);        pPrev->pNext = pBwGroup->pNext;    }    rc = RTCritSectLeave(&pShaper->cs); AssertRC(rc);}

/** * @interface_method_impl{PDMIVMMDEVCONNECTOR,pfnUpdateGuestInfo2} */DECLCALLBACK(void) vmmdevUpdateGuestInfo2(PPDMIVMMDEVCONNECTOR pInterface, uint32_t uFullVersion,                                          const char *pszName, uint32_t uRevision, uint32_t fFeatures){    PDRVMAINVMMDEV pDrv = RT_FROM_MEMBER(pInterface, DRVMAINVMMDEV, Connector);    AssertPtr(pszName);    Assert(uFullVersion);    /* Store that information in IGuest. */    Guest *pGuest = pDrv->pVMMDev->getParent()->i_getGuest();    AssertPtrReturnVoid(pGuest);    /* Just pass it on... */    pGuest->i_setAdditionsInfo2(uFullVersion, pszName, uRevision, fFeatures);    /*     * No need to tell the console interface about the update;     * vmmdevUpdateGuestInfo takes care of that when called as the     * last event in the chain.     */}

/** * Creates our provider. This happens *before* CTRL-ALT-DEL was pressed! */HRESULTVBoxCredProvProviderCreate(REFIID interfaceID, void **ppvInterface){    HRESULT hr;    try    {        VBoxCredProvProvider *pProvider = new VBoxCredProvProvider();        AssertPtr(pProvider);        hr = pProvider->QueryInterface(interfaceID, ppvInterface);        pProvider->Release();    }    catch (std::bad_alloc &ex)    {        NOREF(ex);        hr = E_OUTOFMEMORY;    }    return hr;}

/** * Adds a line number to the module. * * @returns IPRT status code. * @retval  VERR_NOT_SUPPORTED if the module interpret doesn't support adding *          custom symbols. This should be consider a normal response. * @retval  VERR_INVALID_HANDLE if hDbgMod is invalid. * @retval  VERR_DBG_FILE_NAME_OUT_OF_RANGE if the file name is too longer or *          empty. * @retval  VERR_DBG_INVALID_RVA if an image relative address is specified and *          it's not inside any of the segments defined by the module. * @retval  VERR_DBG_INVALID_SEGMENT_INDEX if the segment index isn't valid. * @retval  VERR_DBG_INVALID_SEGMENT_OFFSET if the segment offset is beyond the *          end of the segment. * @retval  VERR_INVALID_PARAMETER if the line number flags sets undefined bits. * * @param   hDbgMod             The module handle. * @param   pszFile             The file name. * @param   uLineNo             The line number. * @param   iSeg                The segment index. * @param   off                 The segment offset. * @param   piOrdinal           Where to return the line number ordinal on *                              success. If  the interpreter doesn't do ordinals, *                              this will be set to UINT32_MAX. Optional. */RTDECL(int) RTDbgModLineAdd(RTDBGMOD hDbgMod, const char *pszFile, uint32_t uLineNo,                            RTDBGSEGIDX iSeg, RTUINTPTR off, uint32_t *piOrdinal){    /*     * Validate input.     */    PRTDBGMODINT pDbgMod = hDbgMod;    RTDBGMOD_VALID_RETURN_RC(pDbgMod, VERR_INVALID_HANDLE);    AssertPtr(pszFile);    size_t cchFile = strlen(pszFile);    AssertReturn(cchFile, VERR_DBG_FILE_NAME_OUT_OF_RANGE);    AssertReturn(cchFile < RTDBG_FILE_NAME_LENGTH, VERR_DBG_FILE_NAME_OUT_OF_RANGE);    AssertMsgReturn(   iSeg <= RTDBGSEGIDX_LAST                    || iSeg == RTDBGSEGIDX_RVA,                    ("%#x/n", iSeg),                    VERR_DBG_INVALID_SEGMENT_INDEX);    AssertReturn(uLineNo > 0 && uLineNo < UINT32_MAX, VERR_INVALID_PARAMETER);    RTDBGMOD_LOCK(pDbgMod);    /*     * Convert RVAs.     */    if (iSeg == RTDBGSEGIDX_RVA)    {        iSeg = pDbgMod->pDbgVt->pfnRvaToSegOff(pDbgMod, off, &off);        if (iSeg == NIL_RTDBGSEGIDX)        {            RTDBGMOD_UNLOCK(pDbgMod);            return VERR_DBG_INVALID_RVA;        }    }    /*     * Get down to business.     */    int rc = pDbgMod->pDbgVt->pfnLineAdd(pDbgMod, pszFile, cchFile, uLineNo, iSeg, off, piOrdinal);    RTDBGMOD_UNLOCK(pDbgMod);    return rc;}

/** * Get the real name of a shared folder. * * @returns VBox status code. * @param   u32ClientId     The client id returned by VbglR3InvsSvcConnect(). * @param   u32Root         Root ID of shared folder to get the name for. * @param   ppszName        Where to return the name string.  This shall be *                          freed by calling RTStrFree. */VBGLR3DECL(int) VbglR3SharedFolderGetName(uint32_t u32ClientId, uint32_t u32Root, char **ppszName){    AssertPtr(ppszName);    VBoxSFQueryMapName Msg;    Msg.callInfo.result = VERR_WRONG_ORDER;    Msg.callInfo.u32ClientID = u32ClientId;    Msg.callInfo.u32Function = SHFL_FN_QUERY_MAP_NAME;    Msg.callInfo.cParms = 2;    int         rc;    uint32_t    cbString = SHFLSTRING_HEADER_SIZE + SHFL_MAX_LEN;    PSHFLSTRING pString = (PSHFLSTRING)RTMemAlloc(cbString);    if (pString)    {        if (!ShflStringInitBuffer(pString, cbString))        {            RTMemFree(pString);            return VERR_INVALID_PARAMETER;        }        VbglHGCMParmUInt32Set(&Msg.root, u32Root);        VbglHGCMParmPtrSet(&Msg.name, pString, cbString);        rc = vbglR3DoIOCtl(VBOXGUEST_IOCTL_HGCM_CALL(sizeof(Msg)), &Msg, sizeof(Msg));        if (RT_SUCCESS(rc))        {            rc = Msg.callInfo.result;            if (RT_SUCCESS(rc))            {                *ppszName = NULL;                rc = RTUtf16ToUtf8(&pString->String.ucs2[0], ppszName);            }        }        RTMemFree(pString);    }    else        rc = VERR_INVALID_PARAMETER;    return rc;}

	QWidget* GetPropertyEditor( AEditableProperty* theProperty )	{		if (theProperty->Is<EdProperty_Bool>())		{			return static_cast< BoolPropertyEditor*>( theProperty->editor.Ptr );		}		else if (theProperty->Is<EdProperty_UInt32>())		{			return static_cast< UInt32PropertyEditor*>( theProperty->editor.Ptr );		}		else if (theProperty->Is<EdProperty_Float>())		{			return static_cast< FloatPropertyEditor*>( theProperty->editor.Ptr );		}		else if (theProperty->Is<EdProperty_Vector3D>())		{			return static_cast< Vec3DPropertyEditor*>( theProperty->editor.Ptr );		}		else if (theProperty->Is<EdProperty_Quat>())		{			return static_cast< QuaternionPropertyEditor*>( theProperty->editor.Ptr );		}		else if (theProperty->Is<EdProperty_Array>())		{			// each item of the array will have a separate editor			return nil;		}		//else if (theProperty->Is<EdProperty_AssetReference>())		//{		//	return static_cast< ResourceRefPropertyEditor*>( theProperty->editor.Ptr );		//}		else		{			APropertyEditor* pEditor = theProperty->editor;			AssertPtr(pEditor);			return static_cast<QWidget*>(static_cast<void*>(pEditor));			/*DBGOUT("Unknown property: '%s'/n",theProperty->edToChars(0));			Unimplemented;			return nil;*/		}	}

/** * Send a byte (keystroke or command response) to the keyboard controller. * * @returns VINF_SUCCESS or VINF_TRY_AGAIN. * @param   pThis               The PS/2 auxiliary device instance data. * @param   pb                  Where to return the byte we've read. * @remarks Caller must have entered the device critical section. */int PS2MByteFromAux(PPS2M pThis, uint8_t *pb){    int         rc;    AssertPtr(pb);    /* Anything in the command queue has priority over data     * in the event queue. Additionally, keystrokes are //@todo: true?     * blocked if a command is currently in progress, even if     * the command queue is empty.     */    //@todo: Probably should flush/not fill queue if stream mode reporting disabled?!    rc = ps2kRemoveQueue((GeneriQ *)&pThis->cmdQ, pb);    if (rc != VINF_SUCCESS && !pThis->u8CurrCmd && (pThis->u8State & AUX_STATE_ENABLED))        rc = ps2kRemoveQueue((GeneriQ *)&pThis->evtQ, pb);    LogFlowFunc(("mouse sends 0x%02x (%svalid data)/n", *pb, rc == VINF_SUCCESS ? "" : "not "));//if (rc == VINF_SUCCESS) LogRel(("aux: sends 0x%02X/n", *pb));    return rc;}

/** @copydoc VBOXHDDBACKEND::pfnSetParentModificationUuid */static DECLCALLBACK(int) rawSetParentModificationUuid(void *pBackendData, PCRTUUID pUuid){    LogFlowFunc(("pBackendData=%#p Uuid=%RTuuid/n", pBackendData, pUuid));    PRAWIMAGE pImage = (PRAWIMAGE)pBackendData;    int rc;    AssertPtr(pImage);    if (pImage)    {        if (!(pImage->uOpenFlags & VD_OPEN_FLAGS_READONLY))            rc = VERR_NOT_SUPPORTED;        else            rc = VERR_VD_IMAGE_READ_ONLY;    }    else        rc = VERR_VD_NOT_OPENED;    LogFlowFunc(("returns %Rrc/n", rc));    return rc;}

RTDECL(void) RTThreadPreemptRestore(PRTTHREADPREEMPTSTATE pState){    AssertPtr(pState);    Assert(pState->u32Reserved == 42);    pState->u32Reserved = 0;    RT_ASSERT_PREEMPT_CPUID_RESTORE(pState);    RTCPUID idCpu = RTMpCpuId();    if (RT_UNLIKELY(idCpu < RT_ELEMENTS(g_aPreemptHacks)))    {        Assert(g_aPreemptHacks[idCpu].cRecursion > 0);        if (--g_aPreemptHacks[idCpu].cRecursion == 0)        {            lck_spin_t *pSpinLock = g_aPreemptHacks[idCpu].pSpinLock;            if (pSpinLock)                lck_spin_unlock(pSpinLock);            else                AssertFailed();        }    }}

int GuestObject::callbackRemoveAll(void){    int vrc = VINF_SUCCESS;    /*     * Cancel all callbacks + waiters.     * Note: Deleting them is the job of the caller!     */    for (GuestCtrlCallbacks::iterator itCallbacks = mObject.mCallbacks.begin();         itCallbacks != mObject.mCallbacks.end(); ++itCallbacks)    {        GuestCtrlCallback *pCallback = itCallbacks->second;        AssertPtr(pCallback);        int rc2 = pCallback->Cancel();        if (RT_SUCCESS(vrc))            vrc = rc2;    }    mObject.mCallbacks.clear();    return vrc;}