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

/** *  Called by setter methods of all USB device filters. * *  @note Locks nothing. */HRESULT USBController::onDeviceFilterChange (USBDeviceFilter *aFilter,                                             BOOL aActiveChanged /* = FALSE */){    AutoCaller autoCaller(this);    AssertComRCReturnRC(autoCaller.rc());    /* we need the machine state */    AutoAnyStateDependency adep(m->pParent);    AssertComRCReturnRC(adep.rc());    /* nothing to do if the machine isn't running */    if (!Global::IsOnline (adep.machineState()))        return S_OK;    /* we don't modify our data fields -- no need to lock */    if (    aFilter->mInList         && m->pParent->isRegistered())    {        USBProxyService *service = m->pHost->usbProxyService();        ComAssertRet(service, E_FAIL);        if (aActiveChanged)        {            if (aFilter->getData().mRemote.isMatch (false))            {                /* insert/remove the filter from the proxy */                if (aFilter->getData().mActive)                {                    ComAssertRet(aFilter->getId() == NULL, E_FAIL);                    aFilter->getId() = service->insertFilter(&aFilter->getData().mUSBFilter);                }                else                {                    ComAssertRet(aFilter->getId() != NULL, E_FAIL);                    service->removeFilter(aFilter->getId());                    aFilter->getId() = NULL;                }            }        }        else        {            if (aFilter->getData().mActive)            {                /* update the filter in the proxy */                ComAssertRet(aFilter->getId() != NULL, E_FAIL);                service->removeFilter(aFilter->getId());                if (aFilter->getData().mRemote.isMatch (false))                {                    aFilter->getId() = service->insertFilter(&aFilter->getData().mUSBFilter);                }            }        }    }    return S_OK;}

/** * Signals that the current operation is successfully completed and advances to * the next operation. The operation percentage is reset to 0. * * @param aOperationDescription     Description of the next operation. * * @note The current operation must not be the last one. */STDMETHODIMP Progress::SetNextOperation(IN_BSTR bstrNextOperationDescription, ULONG ulNextOperationsWeight){    AssertReturn(bstrNextOperationDescription, E_INVALIDARG);    AutoCaller autoCaller(this);    AssertComRCReturnRC(autoCaller.rc());    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);    if (mCanceled)        return E_FAIL;    AssertReturn(!mCompleted, E_FAIL);    AssertReturn(m_ulCurrentOperation + 1 < m_cOperations, E_FAIL);    ++m_ulCurrentOperation;    m_ulOperationsCompletedWeight += m_ulCurrentOperationWeight;    m_bstrOperationDescription = bstrNextOperationDescription;    m_ulCurrentOperationWeight = ulNextOperationsWeight;    m_ulOperationPercent = 0;    Log(("Progress::setNextOperation(%ls): ulNextOperationsWeight = %d; m_ulCurrentOperation is now %d, m_ulOperationsCompletedWeight is now %d/n",         m_bstrOperationDescription.raw(), ulNextOperationsWeight, m_ulCurrentOperation, m_ulOperationsCompletedWeight));    /* wake up all waiting threads */    if (mWaitersCount > 0)        RTSemEventMultiSignal(mCompletedSem);    return S_OK;}

/** *  Initializes the Serial Port object given another serial port object *  (a kind of copy constructor). This object shares data with *  the object passed as an argument. * *  @note This object must be destroyed before the original object *  it shares data with is destroyed. * *  @note Locks @a aThat object for reading. */HRESULT SerialPort::init(Machine *aParent, SerialPort *aThat){    LogFlowThisFunc(("aParent=%p, aThat=%p/n", aParent, aThat));    ComAssertRet(aParent && aThat, E_INVALIDARG);    /* Enclose the state transition NotReady->InInit->Ready */    AutoInitSpan autoInitSpan(this);    AssertReturn(autoInitSpan.isOk(), E_FAIL);    m = new Data();    unconst(m->pMachine) = aParent;    unconst(m->pPeer) = aThat;    AutoCaller thatCaller (aThat);    AssertComRCReturnRC(thatCaller.rc());    AutoReadLock thatLock(aThat COMMA_LOCKVAL_SRC_POS);    m->bd.share (aThat->m->bd);    /* Confirm a successful initialization */    autoInitSpan.setSucceeded();    return S_OK;}

HRESULT USBDeviceFilters::createDeviceFilter(const com::Utf8Str &aName,                                             ComPtr<IUSBDeviceFilter> &aFilter){#ifdef VBOX_WITH_USB    /* the machine needs to be mutable */    AutoMutableStateDependency adep(m->pParent);    if (FAILED(adep.rc())) return adep.rc();    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);    ComObjPtr<USBDeviceFilter> pFilter;    pFilter.createObject();    HRESULT rc = pFilter->init(this, Bstr(aName).raw());    ComAssertComRCRetRC(rc);    rc = pFilter.queryInterfaceTo(aFilter.asOutParam());    AssertComRCReturnRC(rc);    return S_OK;#else    NOREF(aName);    NOREF(aFilter);    ReturnComNotImplemented();#endif}

/** *  Loads settings from the given machine node. *  May be called once right after this object creation. * *  @param aMachineNode <Machine> node. * *  @note Does not lock "this" as Machine::loadHardware, which calls this, does not lock either. */HRESULT USBDeviceFilters::i_loadSettings(const settings::USB &data){    AutoCaller autoCaller(this);    AssertComRCReturnRC(autoCaller.rc());    /* Note: we assume that the default values for attributes of optional     * nodes are assigned in the Data::Data() constructor and don't do it     * here. It implies that this method may only be called after constructing     * a new USBDeviceFilters object while all its data fields are in the default     * values. Exceptions are fields whose creation time defaults don't match     * values that should be applied when these fields are not explicitly set     * in the settings file (for backwards compatibility reasons). This takes     * place when a setting of a newly created object must default to A while     * the same setting of an object loaded from the old settings file must     * default to B. */#ifdef VBOX_WITH_USB    for (settings::USBDeviceFiltersList::const_iterator it = data.llDeviceFilters.begin();         it != data.llDeviceFilters.end();         ++it)    {        const settings::USBDeviceFilter &f = *it;        ComObjPtr<USBDeviceFilter> pFilter;        pFilter.createObject();        HRESULT rc = pFilter->init(this,        // parent                                   f);        if (FAILED(rc)) return rc;        m->llDeviceFilters->push_back(pFilter);        pFilter->mInList = true;    }#endif /* VBOX_WITH_USB */    return S_OK;}

STDMETHODIMP USBController::CreateDeviceFilter (IN_BSTR aName,                                                IUSBDeviceFilter **aFilter){#ifdef VBOX_WITH_USB    CheckComArgOutPointerValid(aFilter);    CheckComArgStrNotEmptyOrNull(aName);    AutoCaller autoCaller(this);    if (FAILED(autoCaller.rc())) return autoCaller.rc();    /* the machine needs to be mutable */    AutoMutableStateDependency adep(m->pParent);    if (FAILED(adep.rc())) return adep.rc();    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);    ComObjPtr<USBDeviceFilter> filter;    filter.createObject();    HRESULT rc = filter->init (this, aName);    ComAssertComRCRetRC (rc);    rc = filter.queryInterfaceTo(aFilter);    AssertComRCReturnRC(rc);    return S_OK;#else    NOREF(aName);    NOREF(aFilter);    ReturnComNotImplemented();#endif}

/** *  Initializes the medium attachment object given another guest object *  (a kind of copy constructor). This object makes a private copy of data *  of the original object passed as an argument. */HRESULT MediumAttachment::initCopy(Machine *aParent, MediumAttachment *aThat){    LogFlowThisFunc(("aParent=%p, aThat=%p/n", aParent, aThat));    ComAssertRet(aParent && aThat, E_INVALIDARG);    /* Enclose the state transition NotReady->InInit->Ready */    AutoInitSpan autoInitSpan(this);    AssertReturn(autoInitSpan.isOk(), E_FAIL);    m = new Data(aParent);    /* m->pPeer is left null */    AutoCaller thatCaller(aThat);    AssertComRCReturnRC(thatCaller.rc());    AutoReadLock thatlock(aThat COMMA_LOCKVAL_SRC_POS);    m->bd.attachCopy(aThat->m->bd);    /* Confirm a successful initialization */    autoInitSpan.setSucceeded();    /* Construct a short log name for this attachment. */    i_updateLogName();    LogFlowThisFunc(("LEAVE - %s/n", i_getLogName()));    return S_OK;}

/** *  Initializes the guest object given another guest object *  (a kind of copy constructor). This object makes a private copy of data *  of the original object passed as an argument. * *  @note Locks @a aThat object for reading. */HRESULT USBDeviceFilter::initCopy(USBDeviceFilters *aParent, USBDeviceFilter *aThat){    LogFlowThisFunc(("aParent=%p, aThat=%p/n", aParent, aThat));    ComAssertRet(aParent && aThat, E_INVALIDARG);    /* Enclose the state transition NotReady->InInit->Ready */    AutoInitSpan autoInitSpan(this);    AssertReturn(autoInitSpan.isOk(), E_FAIL);    unconst(mParent) = aParent;    /* mPeer is left null */    m_fModified = false;    /* sanity */    AutoCaller thatCaller(aThat);    AssertComRCReturnRC(thatCaller.rc());    AutoReadLock thatLock(aThat COMMA_LOCKVAL_SRC_POS);    bd.attachCopy(aThat->bd);    /* reset the arbitrary ID field     * (this field is something unique that two distinct objects, even if they     * are deep copies of each other, should not share) */    bd->mId = NULL;    mInList = aThat->mInList;    /* Confirm successful initialization */    autoInitSpan.setSucceeded();    return S_OK;}

/** * Initializes the VirtualBoxClient object. * * @returns COM result indicator */HRESULT VirtualBoxClient::init(){    LogFlowThisFunc(("/n"));    HRESULT rc;    /* Enclose the state transition NotReady->InInit->Ready */    AutoInitSpan autoInitSpan(this);    AssertReturn(autoInitSpan.isOk(), E_FAIL);    mData.m_ThreadWatcher = NIL_RTTHREAD;    mData.m_SemEvWatcher = NIL_RTSEMEVENT;    if (ASMAtomicIncU32(&g_cInstances) != 1)        AssertFailedReturn(E_FAIL);    rc = mData.m_pVirtualBox.createLocalObject(CLSID_VirtualBox);    AssertComRCReturnRC(rc);    rc = unconst(mData.m_pEventSource).createObject();    AssertComRCReturnRC(rc);    rc = mData.m_pEventSource->init(static_cast<IVirtualBoxClient *>(this));    AssertComRCReturnRC(rc);    /* Setting up the VBoxSVC watcher thread. If anything goes wrong here it     * is not considered important enough to cause any sort of visible     * failure. The monitoring will not be done, but that's all. */    int vrc = RTSemEventCreate(&mData.m_SemEvWatcher);    AssertRC(vrc);    if (RT_SUCCESS(vrc))    {        vrc = RTThreadCreate(&mData.m_ThreadWatcher, SVCWatcherThread,                             this, 0, RTTHREADTYPE_INFREQUENT_POLLER,                             RTTHREADFLAGS_WAITABLE, "VBoxSVCWatcher");        AssertRC(vrc);    }    else    {        RTSemEventDestroy(mData.m_SemEvWatcher);        mData.m_SemEvWatcher = NIL_RTSEMEVENT;    }    /* Confirm a successful initialization */    autoInitSpan.setSucceeded();    return rc;}

/** * Sets the internal result code and attempts to retrieve additional error * info from the current thread. Gets called from Progress::notifyComplete(), * but can be called again to override a previous result set with * notifyComplete(). * * @param aResultCode */HRESULT Progress::setResultCode(HRESULT aResultCode){    AutoCaller autoCaller(this);    AssertComRCReturnRC(autoCaller.rc());    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);    mResultCode = aResultCode;    HRESULT rc = S_OK;    if (FAILED(aResultCode))    {        /* try to import error info from the current thread */#if !defined(VBOX_WITH_XPCOM)        ComPtr<IErrorInfo> err;        rc = ::GetErrorInfo(0, err.asOutParam());        if (rc == S_OK && err)        {            rc = err.queryInterfaceTo(mErrorInfo.asOutParam());            if (SUCCEEDED(rc) && !mErrorInfo)                rc = E_FAIL;        }#else /* !defined(VBOX_WITH_XPCOM) */        nsCOMPtr<nsIExceptionService> es;        es = do_GetService(NS_EXCEPTIONSERVICE_CONTRACTID, &rc);        if (NS_SUCCEEDED(rc))        {            nsCOMPtr <nsIExceptionManager> em;            rc = es->GetCurrentExceptionManager(getter_AddRefs(em));            if (NS_SUCCEEDED(rc))            {                ComPtr<nsIException> ex;                rc = em->GetCurrentException(ex.asOutParam());                if (NS_SUCCEEDED(rc) && ex)                {                    rc = ex.queryInterfaceTo(mErrorInfo.asOutParam());                    if (NS_SUCCEEDED(rc) && !mErrorInfo)                        rc = E_FAIL;                }            }        }#endif /* !defined(VBOX_WITH_XPCOM) */        AssertMsg(rc == S_OK, ("Couldn't get error info (rc=%08X) while trying to set a failed result (%08X)!/n",                               rc, aResultCode));    }    return rc;}

/** *  Loads settings from the given port node. *  May be called once right after this object creation. * *  @param aPortNode <Port> node. * *  @note Locks this object for writing. */HRESULT ParallelPort::i_loadSettings(const settings::ParallelPort &data){    AutoCaller autoCaller(this);    AssertComRCReturnRC(autoCaller.rc());    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);    // simply copy    *m->bd.data() = data;    return S_OK;}

/** *  Saves settings to the given machine node. * *  @param aMachineNode <Machine> node. * *  @note Locks this object for reading. */HRESULT AudioAdapter::saveSettings(settings::AudioAdapter &data){    AutoCaller autoCaller(this);    AssertComRCReturnRC(autoCaller.rc());    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);    data.fEnabled = !!mData->mEnabled;    data.controllerType = mData->mAudioController;    data.driverType = mData->mAudioDriver;    return S_OK;}

/** *  Saves the port settings to the given port node. * *  Note that the given Port node is completely empty on input. * *  @param aPortNode <Port> node. * *  @note Locks this object for reading. */HRESULT SerialPort::i_saveSettings(settings::SerialPort &data){    AutoCaller autoCaller(this);    AssertComRCReturnRC(autoCaller.rc());    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);    // simply copy    data = *m->bd.data();    return S_OK;}

/** * Marks the operation as complete and attaches full error info. * * See VirtualBoxBase::setError(HRESULT, const GUID &, const wchar_t * *, const char *, ...) for more info. * * @param aResultCode   Operation result (error) code, must not be S_OK. * @param aIID          IID of the interface that defines the error. * @param aComponent    Name of the component that generates the error. * @param aText         Error message (must not be null), an RTStrPrintf-like *                      format string in UTF-8 encoding. * @param va            List of arguments for the format string. */HRESULT Progress::i_notifyCompleteV(HRESULT aResultCode,                                    const GUID &aIID,                                    const char *pcszComponent,                                    const char *aText,                                    va_list va){    Utf8Str text(aText, va);    AutoCaller autoCaller(this);    AssertComRCReturnRC(autoCaller.rc());    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);    AssertReturn(mCompleted == FALSE, E_FAIL);    if (mCanceled && SUCCEEDED(aResultCode))        aResultCode = E_FAIL;    mCompleted = TRUE;    mResultCode = aResultCode;    AssertReturn(FAILED(aResultCode), E_FAIL);    ComObjPtr<VirtualBoxErrorInfo> errorInfo;    HRESULT rc = errorInfo.createObject();    AssertComRC(rc);    if (SUCCEEDED(rc))    {        errorInfo->init(aResultCode, aIID, pcszComponent, text);        errorInfo.queryInterfaceTo(mErrorInfo.asOutParam());    }#if !defined VBOX_COM_INPROC    /* remove from the global collection of pending progress operations */    if (mParent)        mParent->i_removeProgress(mId.ref());#endif    /* wake up all waiting threads */    if (mWaitersCount > 0)        RTSemEventMultiSignal(mCompletedSem);    return rc;}

/** * Initializes the keyboard object. * * @returns COM result indicator * @param parent handle of our parent object */HRESULT Keyboard::init(Console *aParent){    LogFlowThisFunc(("aParent=%p/n", aParent));    ComAssertRet(aParent, E_INVALIDARG);    /* Enclose the state transition NotReady->InInit->Ready */    AutoInitSpan autoInitSpan(this);    AssertReturn(autoInitSpan.isOk(), E_FAIL);    unconst(mParent) = aParent;    unconst(mEventSource).createObject();    HRESULT rc = mEventSource->init();    AssertComRCReturnRC(rc);    /* Confirm a successful initialization */    autoInitSpan.setSucceeded();    return S_OK;}