VirtualBox

Changeset 50874 in vbox for trunk/src/VBox/Main/src-client


Ignore:
Timestamp:
Mar 25, 2014 6:29:02 PM (11 years ago)
Author:
vboxsync
svn:sync-xref-src-repo-rev:
92972
Message:

6813 src-all/ProgressImp.cpp + some formatting/line length sorting

Location:
trunk/src/VBox/Main/src-client
Files:
7 edited

Legend:

Unmodified
Added
Removed

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

    r50737 r50874  
    35343534// private methods
    35353535/////////////////////////////////////////////////////////////////////////////
    3536    
     3536
    35373537/**
    35383538 * Suspend the VM before we do any medium or network attachment change.
    … …  
    69086908        /* The progress object will fetch the current error info */
    69096909        if (!pPowerupProgress.isNull())
    6910             pPowerupProgress->notifyComplete(rc);
     6910            pPowerupProgress->i_notifyComplete(rc);
    69116911
    69126912        /* Save the error info across the IPC below. Can't be done before the
    … …  
    91769176                            rc = pMachine->COMGETTER(FaultTolerancePassword)(bstrPassword.asOutParam());
    91779177                    }
    9178                     if (task->mProgress->setCancelCallback(faultToleranceProgressCancelCallback, pConsole->mpUVM))
     9178                    if (task->mProgress->i_setCancelCallback(faultToleranceProgressCancelCallback, pConsole->mpUVM))
    91799179                    {
    91809180                        if (SUCCEEDED(rc))
    … …  
    91989198                            AssertLogRelRC(vrc);
    91999199                        }
    9200                         task->mProgress->setCancelCallback(NULL, NULL);
     9200                        task->mProgress->i_setCancelCallback(NULL, NULL);
    92019201                    }
    92029202                    else
    … …  
    93169316    {
    93179317        /* Notify the progress object of the success */
    9318         task->mProgress->notifyComplete(S_OK);
     9318        task->mProgress->i_notifyComplete(S_OK);
    93199319    }
    93209320    else
    93219321    {
    93229322        /* The progress object will fetch the current error info */
    9323         task->mProgress->notifyComplete(rc);
     9323        task->mProgress->i_notifyComplete(rc);
    93249324        LogRel(("Power up failed (vrc=%Rrc, rc=%Rhrc (%#08X))\n", vrc, rc, rc));
    93259325    }
    … …  
    95189518                Utf8Str strSavedStateFile(pTask->bstrSavedStateFile);
    95199519
    9520                 pTask->mProgress->setCancelCallback(takesnapshotProgressCancelCallback, ptrVM.rawUVM());
     9520                pTask->mProgress->i_setCancelCallback(takesnapshotProgressCancelCallback, ptrVM.rawUVM());
    95219521
    95229522                alock.release();
    … …  
    95349534                                         strSavedStateFile.c_str(), vrc);
    95359535
    9536                 pTask->mProgress->setCancelCallback(NULL, NULL);
     9536                pTask->mProgress->i_setCancelCallback(NULL, NULL);
    95379537            }
    95389538            else
    95399539                LogRel(("Console: skipped saving state as part of online snapshot\n"));
    95409540
    9541             if (!pTask->mProgress->notifyPointOfNoReturn())
     9541            if (!pTask->mProgress->i_notifyPointOfNoReturn())
    95429542                throw setErrorStatic(E_FAIL, tr("Canceled"));
    95439543            that->mptrCancelableProgress.setNull();
    … …  
    96389638
    96399639    if (FAILED(rc)) /* Must come before calling setMachineState. */
    9640         pTask->mProgress->notifyComplete(rc);
     9640        pTask->mProgress->i_notifyComplete(rc);
    96419641
    96429642    /*
    … …  
    96699669                {
    96709670                    rc = setErrorStatic(VBOX_E_VM_ERROR, tr("Could not resume the machine execution (%Rrc)"), vrc);
    9671                     pTask->mProgress->notifyComplete(rc);
     9671                    pTask->mProgress->i_notifyComplete(rc);
    96729672                    if (that->mMachineState == MachineState_Saving)
    96739673                        that->setMachineStateLocally(MachineState_Paused);
    … …  
    97469746
    97479747    if (SUCCEEDED(rc)) /* The failure cases are handled above. */
    9748         pTask->mProgress->notifyComplete(rc);
     9748        pTask->mProgress->i_notifyComplete(rc);
    97499749
    97509750    delete pTask;

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

    r47532 r50874  
    712712     * We're at the point of no return.
    713713     */
    714     if (!pState->mptrProgress->notifyPointOfNoReturn())
     714    if (!pState->mptrProgress->i_notifyPointOfNoReturn())
    715715    {
    716716        teleporterSrcSubmitCommand(pState, "cancel", false /*fWaitForAck*/);
    … …  
    784784       complete things here on failure instead of right before cleanup. */
    785785    if (FAILED(hrc))
    786         pState->mptrProgress->notifyComplete(hrc);
     786        pState->mptrProgress->i_notifyComplete(hrc);
    787787
    788788    /* We can no longer be canceled (success), or it doesn't matter any longer (failure). */
    789     pState->mptrProgress->setCancelCallback(NULL, NULL);
     789    pState->mptrProgress->i_setCancelCallback(NULL, NULL);
    790790
    791791    /*
    … …  
    819819        pState->mptrConsole->mVMIsAlreadyPoweringOff = false;
    820820
    821         pState->mptrProgress->notifyComplete(hrc);
     821        pState->mptrProgress->i_notifyComplete(hrc);
    822822    }
    823823    else
    … …  
    991991
    992992    void *pvUser = static_cast<void *>(static_cast<TeleporterState *>(pState));
    993     ptrProgress->setCancelCallback(teleporterProgressCancelCallback, pvUser);
     993    ptrProgress->i_setCancelCallback(teleporterProgressCancelCallback, pvUser);
    994994
    995995    int vrc = RTThreadCreate(NULL, Console::teleporterSrcThreadWrapper, (void *)pState, 0 /*cbStack*/,
    … …  
    10111011    else
    10121012    {
    1013         ptrProgress->setCancelCallback(NULL, NULL);
     1013        ptrProgress->i_setCancelCallback(NULL, NULL);
    10141014        delete pState;
    10151015        hrc = setError(E_FAIL, tr("RTThreadCreate -> %Rrc"), vrc);
    … …  
    11151115
    11161116            void *pvUser = static_cast<void *>(static_cast<TeleporterState *>(&theState));
    1117             if (pProgress->setCancelCallback(teleporterProgressCancelCallback, pvUser))
     1117            if (pProgress->i_setCancelCallback(teleporterProgressCancelCallback, pvUser))
    11181118            {
    11191119                LogRel(("Teleporter: Waiting for incoming VM...\n"));
    … …  
    11221122                {
    11231123                    vrc = RTTcpServerListen(hServer, Console::teleporterTrgServeConnection, &theState);
    1124                     pProgress->setCancelCallback(NULL, NULL);
     1124                    pProgress->i_setCancelCallback(NULL, NULL);
    11251125
    11261126                    if (vrc == VERR_TCP_SERVER_STOP)
    … …  
    14101410             *       make it possible to recover from some VMR3Resume failures.
    14111411             */
    1412             if (   pState->mptrProgress->notifyPointOfNoReturn()
     1412            if (   pState->mptrProgress->i_notifyPointOfNoReturn()
    14131413                && pState->mfLockedMedia)
    14141414            {

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

    r50734 r50874  
    395395        m_pvData = NULL;
    396396    }
    397     m_cbData = 0;   
     397    m_cbData = 0;
    398398    m_cbDataCurrent = 0;
    399399    m_cbDataTotal = 0;
    … …  
    435435            if (uState == DragAndDropSvc::DND_PROGRESS_ERROR)
    436436            {
    437                 hr = m_progress->notifyComplete(VBOX_E_IPRT_ERROR,
    438                                                 COM_IIDOF(IGuest),
    439                                                 m_parent->getComponentName(),
    440                                                 DnDGuestResponse::errorToString(m_parent, rcOp).c_str());
     437                hr = m_progress->i_notifyComplete(VBOX_E_IPRT_ERROR,
     438                                                  COM_IIDOF(IGuest),
     439                                                  m_parent->getComponentName(),
     440                                                  DnDGuestResponse::errorToString(m_parent, rcOp).c_str());
    441441                reset();
    442442            }
    … …  
    455455                if (   uState      == DragAndDropSvc::DND_PROGRESS_COMPLETE
    456456                    || uPercentage >= 100)
    457                     hr = m_progress->notifyComplete(S_OK);
     457                    hr = m_progress->i_notifyComplete(S_OK);
    458458            }
    459459        }
    … …  
    518518}
    519519
    520 int DnDGuestResponse::writeToFile(const char *pszPath, size_t cbPath, 
     520int DnDGuestResponse::writeToFile(const char *pszPath, size_t cbPath,
    521521                                  void *pvData, size_t cbData, uint32_t fMode)
    522522{
    … …  
    525525     *        keeps those file pointers around, or extend the
    526526     *        actual protocol for explicit open calls.
    527      * 
     527     *
    528528     *        For now we only keep one file open at a time, so if
    529529     *        a client does alternating writes to different files
    … …  
    532532    int rc;
    533533    if (   m_hFile == NIL_RTFILE
    534         || m_strFile != pszPath) 
     534        || m_strFile != pszPath)
    535535    {
    536536        char *pszFile = RTPathJoinA(m_strDropDir.c_str(), pszPath);
    … …  
    540540            /** @todo Respect fMode!  */
    541541            rc = RTFileOpen(&hFile, pszFile,
    542                               RTFILE_O_OPEN_CREATE | RTFILE_O_DENY_WRITE 
     542                              RTFILE_O_OPEN_CREATE | RTFILE_O_DENY_WRITE
    543543                            | RTFILE_O_WRITE | RTFILE_O_APPEND);
    544544            if (RT_SUCCESS(rc))
    545545            {
    546                 LogFlowFunc(("Opening \"%s\" (fMode=0x%x) for writing ...\n", 
     546                LogFlowFunc(("Opening \"%s\" (fMode=0x%x) for writing ...\n",
    547547                             pszFile, fMode));
    548548
    … …  
    955955        *pResultAction = d->toMainAction(pResp->defAction());
    956956
    957         LogFlowFunc(("resFormat=%s, resAction=%RU32\n", 
     957        LogFlowFunc(("resFormat=%s, resAction=%RU32\n",
    958958                     pResp->format().c_str(), pResp->defAction()));
    959959

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

    r50727 r50874  
    487487        if (RT_UNLIKELY(mData.mPID != uPID))
    488488        {
    489             LogFlowFunc(("Stale guest process (PID=%RU32) sent data to a newly started process (pProcesS=%p, PID=%RU32, status=%RU32)\n",
    490                          uPID, this, mData.mPID, mData.mStatus));
     489            Utf8Str str;
     490            str  = "Stale guest process (PID=%RU32) sent data to newly started";
     491            str += " process (pProcesS=%p, PID=%RU32, status=%RU32)\n";
     492            LogFlowFunc((str.c_str(), uPID, this, mData.mPID, mData.mStatus));
    491493            rc = VERR_NOT_FOUND;
    492494        }
    … …  
    13781380    {
    13791381        waitResult = ProcessWaitResult_Error;
    1380         AssertMsg(RT_FAILURE(mData.mLastError), ("No error rc (%Rrc) set when guest process indicated an error\n", mData.mLastError));
     1382        Utf8Str str;
     1383        str  = "No error rc (%Rrc) set when guest process indicated an error\n";
     1384        AssertMsg(RT_FAILURE(mData.mLastError), (str.c_str(), mData.mLastError));
    13811385        if (pGuestRc)
    13821386            *pGuestRc = mData.mLastError; /* Return last set error. */
    … …  
    16621666                              void *pvData, size_t cbData, uint32_t uTimeoutMS, uint32_t *puWritten, int *pGuestRc)
    16631667{
    1664     LogFlowThisFunc(("uPID=%RU32, uHandle=%RU32, uFlags=%RU32, pvData=%p, cbData=%RU32, uTimeoutMS=%RU32, puWritten=%p, pGuestRc=%p\n",
    1665                      mData.mPID, uHandle, uFlags, pvData, cbData, uTimeoutMS, puWritten, pGuestRc));
     1668    Utf8Str str;
     1669    str = "uPID=%RU32, uHandle=%RU32, uFlags=%RU32, pvData=%p, cbData=%RU32, uTimeoutMS=%RU32, puWritten=%p, pGuestRc=%p\n";
     1670    LogFlowThisFunc((str.c_str(), mData.mPID, uHandle, uFlags, pvData, cbData, uTimeoutMS, puWritten, pGuestRc));
    16661671    /* All is optional. There can be 0 byte writes. */
    16671672
    … …  
    18771882}
    18781883
    1879 HRESULT GuestProcess::waitForArray(const std::vector<ProcessWaitForFlag_T> &aWaitFor, ULONG aTimeoutMS, ProcessWaitResult_T *aReason)
    1880 
     1884HRESULT GuestProcess::waitForArray(const std::vector<ProcessWaitForFlag_T> &aWaitFor,
     1885                                   ULONG aTimeoutMS, ProcessWaitResult_T *aReason)
    18811886{
    18821887#ifndef VBOX_WITH_GUEST_CONTROL

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

    r50771 r50874  
    21562156    if (   mData.mProtocolVersion < 2
    21572157        && s_gctrlLegacyWarning++ < 3) /** @todo Find a bit nicer text. */
    2158         LogRel((tr("Warning: Guest Additions are older (%ld.%ld) than host capabilities for guest control, please upgrade them. Using protocol version %ld now\n"),
    2159                 uVBoxMajor, uVBoxMinor, mData.mProtocolVersion));
    2160 
     2158    {
     2159        Utf8Str str;
     2160        str = "Warning: Guest Additions are older (%ld.%ld) than host";
     2161        str += " capabilities for guest control, please upgrade them. Using protocol version %ld now\n";
     2162        LogRel((tr(str.c_str()), uVBoxMajor, uVBoxMinor, mData.mProtocolVersion));
     2163    }
    21612164    return VINF_SUCCESS;
    21622165}
    … …  
    24132416}
    24142417
    2415 HRESULT GuestSession::copyFrom(const com::Utf8Str &aSource, const com::Utf8Str &aDest, const std::vector<CopyFileFlag_T> &aFlags, ComPtr<IProgress> &aProgress)
     2418HRESULT GuestSession::copyFrom(const com::Utf8Str &aSource, const com::Utf8Str &aDest,
     2419                               const std::vector<CopyFileFlag_T> &aFlags,
     2420                               ComPtr<IProgress> &aProgress)
    24162421{
    24172422#ifndef VBOX_WITH_GUEST_CONTROL
    … …  
    24422447        SessionTaskCopyFrom *pTask = new SessionTaskCopyFrom(this /* GuestSession */,
    24432448                                                             aSource, aDest, fFlags);
    2444         int rc = i_startTaskAsync(Utf8StrFmt(tr("Copying \"%s\" from guest to \"%s\" on the host"), aSource.c_str(), aDest.c_str()),
    2445                                 pTask, pProgress);
     2449        int rc = i_startTaskAsync(Utf8StrFmt(tr("Copying \"%s\" from guest to \"%s\" on the host"), aSource.c_str(),
     2450                                  aDest.c_str()), pTask, pProgress);
    24462451        if (RT_SUCCESS(rc))
    24472452            /* Return progress to the caller. */
    … …  
    24602465}
    24612466
    2462 HRESULT GuestSession::copyTo(const com::Utf8Str &aSource, const com::Utf8Str &aDest, const std::vector<CopyFileFlag_T> &aFlags, ComPtr<IProgress> &aProgress)
     2467HRESULT GuestSession::copyTo(const com::Utf8Str &aSource, const com::Utf8Str &aDest, const std::vector<CopyFileFlag_T> &aFlags,
     2468                             ComPtr<IProgress> &aProgress)
    24632469{
    24642470#ifndef VBOX_WITH_GUEST_CONTROL
    … …  
    24902496                                                         aSource, aDest, fFlags);
    24912497        AssertPtrReturn(pTask, E_OUTOFMEMORY);
    2492         int rc = i_startTaskAsync(Utf8StrFmt(tr("Copying \"%s\" from host to \"%s\" on the guest"), aSource.c_str(), aDest.c_str()),
    2493                                 pTask, pProgress);
     2498        int rc = i_startTaskAsync(Utf8StrFmt(tr("Copying \"%s\" from host to \"%s\" on the guest"), aSource.c_str(),
     2499                                  aDest.c_str()), pTask, pProgress);
    24942500        if (RT_SUCCESS(rc))
    24952501        {
    … …  
    25632569}
    25642570
    2565 HRESULT GuestSession::directoryCreateTemp(const com::Utf8Str &aTemplateName, ULONG aMode, const com::Utf8Str &aPath, BOOL aSecure, com::Utf8Str &aDirectory)
     2571HRESULT GuestSession::directoryCreateTemp(const com::Utf8Str &aTemplateName, ULONG aMode, const com::Utf8Str &aPath,
     2572                                          BOOL aSecure, com::Utf8Str &aDirectory)
    25662573{
    25672574#ifndef VBOX_WITH_GUEST_CONTROL
    … …  
    26352642}
    26362643
    2637 HRESULT GuestSession::directoryOpen(const com::Utf8Str &aPath, const com::Utf8Str &aFilter, const std::vector<DirectoryOpenFlag_T> &aFlags, ComPtr<IGuestDirectory> &aDirectory)
     2644HRESULT GuestSession::directoryOpen(const com::Utf8Str &aPath, const com::Utf8Str &aFilter,
     2645                                    const std::vector<DirectoryOpenFlag_T> &aFlags, ComPtr<IGuestDirectory> &aDirectory)
    26382646{
    26392647#ifndef VBOX_WITH_GUEST_CONTROL
    … …  
    27932801}
    27942802
    2795 HRESULT GuestSession::directoryRemoveRecursive(const com::Utf8Str &aPath, const std::vector<DirectoryRemoveRecFlag_T> &aFlags, ComPtr<IProgress> &aProgress)
     2803HRESULT GuestSession::directoryRemoveRecursive(const com::Utf8Str &aPath, const std::vector<DirectoryRemoveRecFlag_T> &aFlags,
     2804                                               ComPtr<IProgress> &aProgress)
    27962805{
    27972806#ifndef VBOX_WITH_GUEST_CONTROL
    … …  
    28202829     *       the progress object right now. */
    28212830     /** @todo Implement progress reporting on guest directory deletion! */
    2822     hr = pProgress->notifyComplete(S_OK);
     2831    hr = pProgress->i_notifyComplete(S_OK);
    28232832    if (FAILED(hr))
    28242833        return hr;
    … …  
    29882997}
    29892998
    2990 HRESULT GuestSession::fileCreateTemp(const com::Utf8Str &aTemplateName, ULONG aMode, const com::Utf8Str &aPath, BOOL aSecure, ComPtr<IGuestFile> &aFile)
     2999HRESULT GuestSession::fileCreateTemp(const com::Utf8Str &aTemplateName, ULONG aMode, const com::Utf8Str &aPath, BOOL aSecure,
     3000                                     ComPtr<IGuestFile> &aFile)
    29913001{
    29923002#ifndef VBOX_WITH_GUEST_CONTROL
    … …  
    30733083}
    30743084
    3075 HRESULT GuestSession::fileOpen(const com::Utf8Str &aPath, const com::Utf8Str &aOpenMode, const com::Utf8Str &aDisposition, ULONG aCreationMode, ComPtr<IGuestFile> &aFile)
     3085HRESULT GuestSession::fileOpen(const com::Utf8Str &aPath, const com::Utf8Str &aOpenMode, const com::Utf8Str &aDisposition,
     3086                               ULONG aCreationMode, ComPtr<IGuestFile> &aFile)
    30763087{
    30773088#ifndef VBOX_WITH_GUEST_CONTROL
    … …  
    30873098}
    30883099
    3089 HRESULT GuestSession::fileOpenEx(const com::Utf8Str &aPath, const com::Utf8Str &aOpenMode, const com::Utf8Str &aDisposition, const com::Utf8Str &aSharingMode, ULONG aCreationMode, LONG64 aOffset, ComPtr<IGuestFile> &aFile)
     3100HRESULT GuestSession::fileOpenEx(const com::Utf8Str &aPath, const com::Utf8Str &aOpenMode, const com::Utf8Str &aDisposition,
     3101                                 const com::Utf8Str &aSharingMode, ULONG aCreationMode, LONG64 aOffset,
     3102                                 ComPtr<IGuestFile> &aFile)
    30903103
    30913104{
    … …  
    32403253}
    32413254
    3242 HRESULT GuestSession::fileRename(const com::Utf8Str &aSource, const com::Utf8Str &aDest, const std::vector<PathRenameFlag_T> &aFlags)
     3255HRESULT GuestSession::fileRename(const com::Utf8Str &aSource, const com::Utf8Str &aDest,
     3256                                 const std::vector<PathRenameFlag_T> &aFlags)
    32433257{
    32443258#ifndef VBOX_WITH_GUEST_CONTROL
    … …  
    32983312}
    32993313
    3300 HRESULT GuestSession::processCreate(const com::Utf8Str &aCommand, const std::vector<com::Utf8Str> &aArguments, const std::vector<com::Utf8Str> &aEnvironment, const std::vector<ProcessCreateFlag_T> &aFlags, ULONG aTimeoutMS, ComPtr<IGuestProcess> &aGuestProcess)
     3314HRESULT GuestSession::processCreate(const com::Utf8Str &aCommand, const std::vector<com::Utf8Str> &aArguments,
     3315                                    const std::vector<com::Utf8Str> &aEnvironment,
     3316                                    const std::vector<ProcessCreateFlag_T> &aFlags,
     3317                                    ULONG aTimeoutMS, ComPtr<IGuestProcess> &aGuestProcess)
    33013318{
    33023319#ifndef VBOX_WITH_GUEST_CONTROL
    … …  
    33073324    std::vector<LONG> affinityIgnored;
    33083325
    3309     return processCreateEx(aCommand, aArguments, aEnvironment, aFlags, aTimeoutMS, ProcessPriority_Default, affinityIgnored, aGuestProcess);
    3310 #endif /* VBOX_WITH_GUEST_CONTROL */
    3311 }
    3312 
    3313 HRESULT GuestSession::processCreateEx(const com::Utf8Str &aCommand, const std::vector<com::Utf8Str> &aArguments, const std::vector<com::Utf8Str> &aEnvironment, const std::vector<ProcessCreateFlag_T> &aFlags, ULONG aTimeoutMS, ProcessPriority_T aPriority, const std::vector<LONG> &aAffinity, ComPtr<IGuestProcess> &aGuestProcess)
     3326    return processCreateEx(aCommand, aArguments, aEnvironment, aFlags, aTimeoutMS, ProcessPriority_Default,
     3327                           affinityIgnored, aGuestProcess);
     3328#endif /* VBOX_WITH_GUEST_CONTROL */
     3329}
     3330
     3331HRESULT GuestSession::processCreateEx(const com::Utf8Str &aCommand, const std::vector<com::Utf8Str> &aArguments,
     3332                                      const std::vector<com::Utf8Str> &aEnvironment,
     3333                                      const std::vector<ProcessCreateFlag_T> &aFlags, ULONG aTimeoutMS,
     3334                                      ProcessPriority_T aPriority, const std::vector<LONG> &aAffinity,
     3335                                      ComPtr<IGuestProcess> &aGuestProcess)
    33143336{
    33153337#ifndef VBOX_WITH_GUEST_CONTROL
    … …  
    34503472}
    34513473
    3452 HRESULT GuestSession::symlinkRead(const com::Utf8Str &aSymlink, const std::vector<SymlinkReadFlag_T> &aFlags, com::Utf8Str &aTarget)
     3474HRESULT GuestSession::symlinkRead(const com::Utf8Str &aSymlink, const std::vector<SymlinkReadFlag_T> &aFlags,
     3475                                  com::Utf8Str &aTarget)
    34533476{
    34543477#ifndef VBOX_WITH_GUEST_CONTROL
    … …  
    35273550}
    35283551
    3529 HRESULT GuestSession::waitForArray(const std::vector<GuestSessionWaitForFlag_T> &aWaitFor, ULONG aTimeoutMS, GuestSessionWaitResult_T *aReason)
     3552HRESULT GuestSession::waitForArray(const std::vector<GuestSessionWaitForFlag_T> &aWaitFor, ULONG aTimeoutMS,
     3553                                   GuestSessionWaitResult_T *aReason)
    35303554{
    35313555#ifndef VBOX_WITH_GUEST_CONTROL

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

    r50727 r50874  
    128128        && !fCompleted)
    129129    {
    130         HRESULT hr = mProgress->notifyComplete(S_OK);
     130        HRESULT hr = mProgress->i_notifyComplete(S_OK);
    131131        if (FAILED(hr))
    132132            return VERR_COM_UNEXPECTED; /** @todo Find a better rc. */
    … …  
    151151        && !fCompleted)
    152152    {
    153         HRESULT hr2 = mProgress->notifyComplete(hr,
    154                                                 COM_IIDOF(IGuestSession),
    155                                                 GuestSession::getStaticComponentName(),
    156                                                 strMsg.c_str());
     153        HRESULT hr2 = mProgress->i_notifyComplete(hr,
     154                                                  COM_IIDOF(IGuestSession),
     155                                                  GuestSession::getStaticComponentName(),
     156                                                  strMsg.c_str());
    157157        if (FAILED(hr2))
    158158            return hr2;

  • trunk/src/VBox/Main/src-client/xpcom/module.cpp

    r50727 r50874  
    7474NS_DECL_CLASSINFO(MachineDebugger)
    7575NS_IMPL_THREADSAFE_ISUPPORTS1_CI(MachineDebugger, IMachineDebugger)
    76 NS_DECL_CLASSINFO(Progress)
    77 NS_IMPL_THREADSAFE_ISUPPORTS1_CI(Progress, IProgress)
    7876NS_DECL_CLASSINFO(RemoteUSBDevice)
    7977NS_IMPL_THREADSAFE_ISUPPORTS2_CI(RemoteUSBDevice, IHostUSBDevice, IUSBDevice)
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