VirtualBox

Changeset 32718 in vbox for trunk/src


Ignore:
Timestamp:
Sep 23, 2010 12:57:52 PM (14 years ago)
Author:
vboxsync
Message:

com/string: Remove bool conversion operator and other convenience error operators. They are hiding programming errors (like incorrect empty string checks, and in one case a free of the wrong pointer).

Location:
trunk/src/VBox
Files:
43 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/VBox/Frontends/VBoxHeadless/VBoxHeadless.cpp

    r31974 r32718  
    162162                            {
    163163                                Bstr value1;
    164                                 hrc = machine->GetExtraData(Bstr("VRDP/DisconnectOnGuestLogout"), value1.asOutParam());
     164                                hrc = machine->GetExtraData(Bstr("VRDP/DisconnectOnGuestLogout").raw(),
     165                                                            value1.asOutParam());
    165166                                if (SUCCEEDED(hrc) && value1 == "1")
    166167                                {
    … …  
    798799        if (id.isEmpty())
    799800        {
    800             rc = virtualBox->FindMachine(Bstr(name), m.asOutParam());
     801            rc = virtualBox->FindMachine(Bstr(name).raw(), m.asOutParam());
    801802            if (FAILED(rc))
    802803            {
    … …  
    812813        {
    813814            /* Use the GUID. */
    814             rc = virtualBox->GetMachine(id, m.asOutParam());
     815            rc = virtualBox->GetMachine(id.raw(), m.asOutParam());
    815816            if (FAILED(rc))
    816817            {
    … …  
    10541055            {
    10551056                Bstr bstr = vrdpPort;
    1056                 CHECK_ERROR_BREAK(vrdpServer, COMSETTER(Ports)(bstr));
     1057                CHECK_ERROR_BREAK(vrdpServer, COMSETTER(Ports)(bstr.raw()));
    10571058            }
    10581059            /* set VRDP address if requested by the user */
    10591060            if (vrdpAddress != NULL)
    10601061            {
    1061                 CHECK_ERROR_BREAK(vrdpServer, COMSETTER(NetAddress)(Bstr(vrdpAddress)));
     1062                CHECK_ERROR_BREAK(vrdpServer, COMSETTER(NetAddress)(Bstr(vrdpAddress).raw()));
    10621063            }
    10631064            /* enable VRDP server (only if currently disabled) */

  • trunk/src/VBox/Frontends/VBoxHeadless/testcase/tstHeadless.cpp

    r31070 r32718  
    115115
    116116        // find ID by name
    117         CHECK_ERROR_BREAK(virtualBox, FindMachine(Bstr(name), m.asOutParam()));
     117        CHECK_ERROR_BREAK(virtualBox, FindMachine(Bstr(name).raw(),
     118                                                  m.asOutParam()));
    118119
    119120        if (!strcmp(operation, "on"))
    … …  
    122123            RTPrintf ("Opening a new (remote) session...\n");
    123124            CHECK_ERROR_BREAK (m,
    124                                LaunchVMProcess(session, Bstr("vrdp"),
     125                               LaunchVMProcess(session, Bstr("vrdp").raw(),
    125126                                               NULL, progress.asOutParam()));
    126127

  • trunk/src/VBox/Frontends/VBoxManage/VBoxInternalManage.cpp

    r32709 r32718  
    256256static HRESULT NewUniqueKey(ComPtr<IMachine> pMachine, const char *pszKeyBase, Utf8Str &rKey)
    257257{
     258    Bstr KeyBase(pszKeyBase);
    258259    Bstr Keys;
    259     HRESULT hrc = pMachine->GetExtraData(Bstr(pszKeyBase), Keys.asOutParam());
     260    HRESULT hrc = pMachine->GetExtraData(KeyBase.raw(), Keys.asOutParam());
    260261    if (FAILED(hrc))
    261262        return hrc;
    … …  
    265266    {
    266267        rKey = "1";
    267         return pMachine->SetExtraData(Bstr(pszKeyBase), Bstr("1"));
     268        return pMachine->SetExtraData(KeyBase.raw(), Bstr(rKey).raw());
    268269    }
    269270
    … …  
    290291            rKey = szKey;
    291292            Utf8StrFmt NewKeysUtf8("%s %s", pszKeys, szKey);
    292             return pMachine->SetExtraData(Bstr(pszKeyBase), Bstr(NewKeysUtf8));
     293            return pMachine->SetExtraData(KeyBase.raw(),
     294                                          Bstr(NewKeysUtf8).raw());
    293295        }
    294296    }
    … …  
    376378static HRESULT SetString(ComPtr<IMachine> pMachine, const char *pszKeyBase, const char *pszKey, const char *pszAttribute, const char *pszValue)
    377379{
    378     HRESULT hrc = pMachine->SetExtraData(Bstr(Utf8StrFmt("%s/%s/%s", pszKeyBase, pszKey, pszAttribute)), Bstr(pszValue));
     380    HRESULT hrc = pMachine->SetExtraData(BstrFmt("%s/%s/%s", pszKeyBase,
     381                                                 pszKey, pszAttribute).raw(),
     382                                         Bstr(pszValue).raw());
    379383    if (FAILED(hrc))
    380384        RTMsgError("Failed to set '%s/%s/%s' to '%s'! hrc=%#x",
    … …  
    432436    ComPtr<IMachine> machine;
    433437    /* assume it's a UUID */
    434     rc = aVirtualBox->GetMachine(Bstr(argv[0]), machine.asOutParam());
     438    rc = aVirtualBox->GetMachine(Bstr(argv[0]).raw(), machine.asOutParam());
    435439    if (FAILED(rc) || !machine)
    436440    {
    437441        /* must be a name */
    438         CHECK_ERROR_RET(aVirtualBox, FindMachine(Bstr(argv[0]), machine.asOutParam()), 1);
     442        CHECK_ERROR_RET(aVirtualBox, FindMachine(Bstr(argv[0]).raw(),
     443                                                 machine.asOutParam()), 1);
    439444    }
    440445
    … …  
    14731478    {
    14741479        ComPtr<IMedium> hardDisk;
    1475         CHECK_ERROR(aVirtualBox, OpenMedium(Bstr(filename), DeviceType_HardDisk, AccessMode_ReadWrite, hardDisk.asOutParam()));
     1480        CHECK_ERROR(aVirtualBox, OpenMedium(Bstr(filename).raw(),
     1481                                            DeviceType_HardDisk,
     1482                                            AccessMode_ReadWrite,
     1483                                            hardDisk.asOutParam()));
    14761484    }
    14771485
    … …  
    18901898
    18911899    ComPtr<IMachine> ptrMachine;
    1892     HRESULT rc = aVirtualBox->GetMachine(Bstr(argv[0]), ptrMachine.asOutParam());
     1900    HRESULT rc = aVirtualBox->GetMachine(Bstr(argv[0]).raw(),
     1901                                         ptrMachine.asOutParam());
    18931902    if (FAILED(rc) || ptrMachine.isNull())
    1894         CHECK_ERROR_RET(aVirtualBox, FindMachine(Bstr(argv[0]), ptrMachine.asOutParam()), 1);
     1903        CHECK_ERROR_RET(aVirtualBox, FindMachine(Bstr(argv[0]).raw(),
     1904                                                 ptrMachine.asOutParam()), 1);
    18951905
    18961906    CHECK_ERROR_RET(ptrMachine, LockMachine(aSession, LockType_Shared), 1);

  • trunk/src/VBox/Frontends/VBoxManage/VBoxManageControlVM.cpp

    r32701 r32718  
    7878    if (!Guid(machineuuid).isEmpty())
    7979    {
    80         CHECK_ERROR(a->virtualBox, GetMachine(machineuuid, machine.asOutParam()));
     80        CHECK_ERROR(a->virtualBox, GetMachine(machineuuid.raw(),
     81                                              machine.asOutParam()));
    8182    }
    8283    else
    8384    {
    84         CHECK_ERROR(a->virtualBox, FindMachine(machineuuid, machine.asOutParam()));
     85        CHECK_ERROR(a->virtualBox, FindMachine(machineuuid.raw(),
     86                                               machine.asOutParam()));
    8587        if (SUCCEEDED (rc))
    8688            machine->COMGETTER(Id)(machineuuid.asOutParam());
    … …  
    329331                    if (a->argv[2])
    330332                    {
    331                         CHECK_ERROR_RET(adapter, COMSETTER(TraceFile)(Bstr(a->argv[2])), 1);
     333                        CHECK_ERROR_RET(adapter, COMSETTER(TraceFile)(Bstr(a->argv[2]).raw()), 1);
    332334                    }
    333335                    else
    … …  
    430432                        CHECK_ERROR_RET(adapter, COMSETTER(Enabled)(TRUE), 1);
    431433                        if (a->argc == 4)
    432                             CHECK_ERROR_RET(adapter, COMSETTER(NATNetwork)(Bstr(a->argv[3])), 1);
     434                            CHECK_ERROR_RET(adapter, COMSETTER(NATNetwork)(Bstr(a->argv[3]).raw()), 1);
    433435                        CHECK_ERROR_RET(adapter, AttachToNAT(), 1);
    434436                    }
    … …  
    443445                        }
    444446                        CHECK_ERROR_RET(adapter, COMSETTER(Enabled)(TRUE), 1);
    445                         CHECK_ERROR_RET(adapter, COMSETTER(HostInterface)(Bstr(a->argv[3])), 1);
     447                        CHECK_ERROR_RET(adapter, COMSETTER(HostInterface)(Bstr(a->argv[3]).raw()), 1);
    446448                        CHECK_ERROR_RET(adapter, AttachToBridgedInterface(), 1);
    447449                    }
    … …  
    455457                        }
    456458                        CHECK_ERROR_RET(adapter, COMSETTER(Enabled)(TRUE), 1);
    457                         CHECK_ERROR_RET(adapter, COMSETTER(InternalNetwork)(Bstr(a->argv[3])), 1);
     459                        CHECK_ERROR_RET(adapter, COMSETTER(InternalNetwork)(Bstr(a->argv[3]).raw()), 1);
    458460                        CHECK_ERROR_RET(adapter, AttachToInternalNetwork(), 1);
    459461                    }
    … …  
    468470                        }
    469471                        CHECK_ERROR_RET(adapter, COMSETTER(Enabled)(TRUE), 1);
    470                         CHECK_ERROR_RET(adapter, COMSETTER(HostInterface)(Bstr(a->argv[3])), 1);
     472                        CHECK_ERROR_RET(adapter, COMSETTER(HostInterface)(Bstr(a->argv[3]).raw()), 1);
    471473                        CHECK_ERROR_RET(adapter, AttachToHostOnlyInterface(), 1);
    472474                    }
    … …  
    534536                    vrdpports = "0";
    535537                else
    536                     vrdpports = a->argv [2];
    537 
    538                 CHECK_ERROR_BREAK(vrdpServer, COMSETTER(Ports)(vrdpports));
     538                    vrdpports = a->argv[2];
     539
     540                CHECK_ERROR_BREAK(vrdpServer, COMSETTER(Ports)(vrdpports.raw()));
    539541            }
    540542        }
    … …  
    571573            bool attach = !strcmp(a->argv[1], "usbattach");
    572574
    573             Bstr usbId = a->argv [2];
     575            Bstr usbId = a->argv[2];
    574576            if (Guid(usbId).isEmpty())
    575577            {
    … …  
    582584                    CHECK_ERROR_BREAK(host, COMGETTER(USBDevices)(ComSafeArrayAsOutParam(coll)));
    583585                    ComPtr <IHostUSBDevice> dev;
    584                     CHECK_ERROR_BREAK(host, FindUSBDeviceByAddress(Bstr(a->argv [2]), dev.asOutParam()));
     586                    CHECK_ERROR_BREAK(host, FindUSBDeviceByAddress(Bstr(a->argv[2]).raw(),
     587                                                                   dev.asOutParam()));
    585588                    CHECK_ERROR_BREAK(dev, COMGETTER(Id)(usbId.asOutParam()));
    586589                }
    … …  
    590593                    CHECK_ERROR_BREAK(console, COMGETTER(USBDevices)(ComSafeArrayAsOutParam(coll)));
    591594                    ComPtr <IUSBDevice> dev;
    592                     CHECK_ERROR_BREAK(console, FindUSBDeviceByAddress(Bstr(a->argv [2]),
    593                                                        dev.asOutParam()));
     595                    CHECK_ERROR_BREAK(console, FindUSBDeviceByAddress(Bstr(a->argv[2]).raw(),
     596                                                                      dev.asOutParam()));
    594597                    CHECK_ERROR_BREAK(dev, COMGETTER(Id)(usbId.asOutParam()));
    595598                }
    … …  
    597600
    598601            if (attach)
    599                 CHECK_ERROR_BREAK(console, AttachUSBDevice(usbId));
     602                CHECK_ERROR_BREAK(console, AttachUSBDevice(usbId.raw()));
    600603            else
    601604            {
    602605                ComPtr <IUSBDevice> dev;
    603                 CHECK_ERROR_BREAK(console, DetachUSBDevice(usbId, dev.asOutParam()));
     606                CHECK_ERROR_BREAK(console, DetachUSBDevice(usbId.raw(),
     607                                                           dev.asOutParam()));
    604608            }
    605609        }
    … …  
    647651            ComPtr<IGuest> guest;
    648652            CHECK_ERROR_BREAK(console, COMGETTER(Guest)(guest.asOutParam()));
    649             CHECK_ERROR_BREAK(guest, SetCredentials(Bstr(a->argv[2]), Bstr(a->argv[3]), Bstr(a->argv[4]), fAllowLocalLogon));
     653            CHECK_ERROR_BREAK(guest, SetCredentials(Bstr(a->argv[2]).raw(),
     654                                                    Bstr(a->argv[3]).raw(),
     655                                                    Bstr(a->argv[4]).raw(),
     656                                                    fAllowLocalLogon));
    650657        }
    651658#if 0 /* TODO: review & remove */
    … …  
    836843
    837844            ComPtr<IProgress> progress;
    838             CHECK_ERROR_BREAK(console, Teleport(bstrHostname, uPort, bstrPassword, uMaxDowntime, progress.asOutParam()));
     845            CHECK_ERROR_BREAK(console, Teleport(bstrHostname.raw(), uPort,
     846                                                bstrPassword.raw(),
     847                                                uMaxDowntime,
     848                                                progress.asOutParam()));
    839849
    840850            if (cMsTimeout)

  • trunk/src/VBox/Frontends/VBoxManage/VBoxManageDisk.cpp

    r32701 r32718  
    258258
    259259    /* check the outcome */
    260     if (   !filename
     260    if (   filename.isEmpty()
    261261        || size == 0)
    262262        return errorSyntax(USAGE_CREATEHD, "Parameters --filename and --size are required");
    … …  
    277277
    278278    ComPtr<IMedium> hardDisk;
    279     CHECK_ERROR(a->virtualBox, CreateHardDisk(format, filename, hardDisk.asOutParam()));
     279    CHECK_ERROR(a->virtualBox, CreateHardDisk(format.raw(), filename.raw(),
     280                                              hardDisk.asOutParam()));
    280281    if (SUCCEEDED(rc) && hardDisk)
    281282    {
    … …  
    286287        if (!comment.isEmpty())
    287288        {
    288             CHECK_ERROR(hardDisk,COMSETTER(Description)(comment));
     289            CHECK_ERROR(hardDisk,COMSETTER(Description)(comment.raw()));
    289290        }
    290291
    … …  
    416417
    417418    /* first guess is that it's a UUID */
    418     CHECK_ERROR(a->virtualBox, FindMedium(Bstr(FilenameOrUuid), DeviceType_HardDisk, hardDisk.asOutParam()));
     419    CHECK_ERROR(a->virtualBox, FindMedium(Bstr(FilenameOrUuid).raw(),
     420                                          DeviceType_HardDisk,
     421                                          hardDisk.asOutParam()));
    419422    if (FAILED(rc))
    420423        return 1;
    … …  
    447450        {
    448451            unknown = true;
    449             rc = a->virtualBox->OpenMedium(Bstr(FilenameOrUuid), DeviceType_HardDisk, AccessMode_ReadWrite, hardDisk.asOutParam());
     452            rc = a->virtualBox->OpenMedium(Bstr(FilenameOrUuid).raw(),
     453                                           DeviceType_HardDisk,
     454                                           AccessMode_ReadWrite,
     455                                           hardDisk.asOutParam());
    450456            if (rc == VBOX_E_FILE_ERROR)
    451457            {
    … …  
    457463                    return 1;
    458464                }
    459                 CHECK_ERROR(a->virtualBox, OpenMedium(Bstr(szFilenameAbs), DeviceType_HardDisk, AccessMode_ReadWrite, hardDisk.asOutParam()));
     465                CHECK_ERROR(a->virtualBox, OpenMedium(Bstr(szFilenameAbs).raw(),
     466                                                      DeviceType_HardDisk,
     467                                                      AccessMode_ReadWrite,
     468                                                      hardDisk.asOutParam()));
    460469            }
    461470        }
    … …  
    487496        {
    488497            unknown = true;
    489             rc = a->virtualBox->OpenMedium(Bstr(FilenameOrUuid), DeviceType_HardDisk, AccessMode_ReadWrite, hardDisk.asOutParam());
     498            rc = a->virtualBox->OpenMedium(Bstr(FilenameOrUuid).raw(),
     499                                           DeviceType_HardDisk,
     500                                           AccessMode_ReadWrite,
     501                                           hardDisk.asOutParam());
    490502            if (rc == VBOX_E_FILE_ERROR)
    491503            {
    … …  
    497509                    return 1;
    498510                }
    499                 CHECK_ERROR(a->virtualBox, OpenMedium(Bstr(szFilenameAbs), DeviceType_HardDisk, AccessMode_ReadWrite, hardDisk.asOutParam()));
     511                CHECK_ERROR(a->virtualBox, OpenMedium(Bstr(szFilenameAbs).raw(),
     512                                                      DeviceType_HardDisk,
     513                                                      AccessMode_ReadWrite,
     514                                                      hardDisk.asOutParam()));
    500515            }
    501516        }
    … …  
    633648    bool fDstUnknown = false;
    634649
    635     rc = a->virtualBox->FindMedium(src, DeviceType_HardDisk, srcDisk.asOutParam());
     650    rc = a->virtualBox->FindMedium(src.raw(), DeviceType_HardDisk,
     651                                   srcDisk.asOutParam());
    636652    /* no? well, then it's an unknown image */
    637653    if (FAILED (rc))
    638654    {
    639         rc = a->virtualBox->OpenMedium(src, DeviceType_HardDisk, AccessMode_ReadWrite, srcDisk.asOutParam());
     655        rc = a->virtualBox->OpenMedium(src.raw(), DeviceType_HardDisk,
     656                                       AccessMode_ReadWrite,
     657                                       srcDisk.asOutParam());
    640658        if (rc == VBOX_E_FILE_ERROR)
    641659        {
    … …  
    647665                return 1;
    648666            }
    649             CHECK_ERROR(a->virtualBox, OpenMedium(Bstr(szFilenameAbs), DeviceType_HardDisk, AccessMode_ReadWrite, srcDisk.asOutParam()));
    650         }
    651         if (SUCCEEDED (rc))
     667            CHECK_ERROR(a->virtualBox, OpenMedium(Bstr(szFilenameAbs).raw(),
     668                                                  DeviceType_HardDisk,
     669                                                  AccessMode_ReadWrite,
     670                                                  srcDisk.asOutParam()));
     671        }
     672        if (SUCCEEDED(rc))
    652673            fSrcUnknown = true;
    653674    }
    … …  
    661682        if (fExisting)
    662683        {
    663             rc = a->virtualBox->FindMedium(dst, DeviceType_HardDisk, dstDisk.asOutParam());
     684            rc = a->virtualBox->FindMedium(dst.raw(), DeviceType_HardDisk,
     685                                           dstDisk.asOutParam());
    664686            /* no? well, then it's an unknown image */
    665             if (FAILED (rc))
     687            if (FAILED(rc))
    666688            {
    667                 rc = a->virtualBox->OpenMedium(dst, DeviceType_HardDisk, AccessMode_ReadWrite, dstDisk.asOutParam());
     689                rc = a->virtualBox->OpenMedium(dst.raw(), DeviceType_HardDisk,
     690                                               AccessMode_ReadWrite,
     691                                               dstDisk.asOutParam());
    668692                if (rc == VBOX_E_FILE_ERROR)
    669693                {
    … …  
    675699                        return 1;
    676700                    }
    677                     CHECK_ERROR_BREAK(a->virtualBox, OpenMedium(Bstr(szFilenameAbs), DeviceType_HardDisk, AccessMode_ReadWrite, dstDisk.asOutParam()));
     701                    CHECK_ERROR_BREAK(a->virtualBox, OpenMedium(Bstr(szFilenameAbs).raw(),
     702                                                                DeviceType_HardDisk,
     703                                                                AccessMode_ReadWrite,
     704                                                                dstDisk.asOutParam()));
    678705                }
    679                 if (SUCCEEDED (rc))
     706                if (SUCCEEDED(rc))
    680707                    fDstUnknown = true;
    681708            }
    … …  
    688715                CHECK_ERROR_BREAK(dstDisk, RefreshState(&state));
    689716            }
    690             CHECK_ERROR_BREAK(dstDisk, COMGETTER(Format) (format.asOutParam()));
     717            CHECK_ERROR_BREAK(dstDisk, COMGETTER(Format)(format.asOutParam()));
    691718        }
    692719        else
    … …  
    694721            /* use the format of the source hard disk if unspecified */
    695722            if (format.isEmpty())
    696                 CHECK_ERROR_BREAK(srcDisk, COMGETTER(Format) (format.asOutParam()));
    697             CHECK_ERROR_BREAK(a->virtualBox, CreateHardDisk(format, dst, dstDisk.asOutParam()));
     723                CHECK_ERROR_BREAK(srcDisk, COMGETTER(Format)(format.asOutParam()));
     724            CHECK_ERROR_BREAK(a->virtualBox, CreateHardDisk(format.raw(),
     725                                                            dst.raw(),
     726                                                            dstDisk.asOutParam()));
    698727        }
    699728
    … …  
    895924        cbRead = 0;
    896925        cbToRead = cbFile - offFile >= (uint64_t)cbBuffer ?
    897                             cbBuffer : (size_t) (cbFile - offFile);
     926                            cbBuffer : (size_t)(cbFile - offFile);
    898927        rc = RTFileRead(File, pvBuf, cbToRead, &cbRead);
    899928        if (RT_FAILURE(rc) || !cbRead)
    … …  
    10241053
    10251054    /* check for required options */
    1026     if (!server || !target)
     1055    if (server.isEmpty() || target.isEmpty())
    10271056        return errorSyntax(USAGE_ADDISCSIDISK, "Parameters --server and --target are required");
    10281057
    … …  
    10361065        if (lun.isEmpty() || lun == "0" || lun == "enc0")
    10371066        {
    1038             CHECK_ERROR_BREAK (a->virtualBox,
    1039                 CreateHardDisk(Bstr ("iSCSI"),
    1040                                BstrFmt ("%ls|%ls", server.raw(), target.raw()),
    1041                                hardDisk.asOutParam()));
     1067            CHECK_ERROR_BREAK(a->virtualBox, CreateHardDisk(Bstr("iSCSI").raw(),
     1068                                                            BstrFmt("%ls|%ls",
     1069                                                                    server.raw(),
     1070                                                                    target.raw()).raw(),
     1071                                                            hardDisk.asOutParam()));
    10421072        }
    10431073        else
    10441074        {
    1045             CHECK_ERROR_BREAK (a->virtualBox,
    1046                 CreateHardDisk(Bstr ("iSCSI"),
    1047                                BstrFmt ("%ls|%ls|%ls", server.raw(), target.raw(), lun.raw()),
    1048                                hardDisk.asOutParam()));
     1075            CHECK_ERROR_BREAK(a->virtualBox, CreateHardDisk(Bstr("iSCSI").raw(),
     1076                                                            BstrFmt("%ls|%ls|%ls",
     1077                                                                    server.raw(),
     1078                                                                    target.raw(),
     1079                                                                    lun.raw()).raw(),
     1080                                                            hardDisk.asOutParam()));
    10491081        }
    10501082        if (FAILED(rc)) break;
    10511083
    10521084        if (!port.isEmpty())
    1053             server = BstrFmt ("%ls:%ls", server.raw(), port.raw());
     1085            server = BstrFmt("%ls:%ls", server.raw(), port.raw());
    10541086
    10551087        com::SafeArray <BSTR> names;
    10561088        com::SafeArray <BSTR> values;
    10571089
    1058         Bstr ("TargetAddress").detachTo (names.appendedRaw());
    1059         server.detachTo (values.appendedRaw());
    1060         Bstr ("TargetName").detachTo (names.appendedRaw());
    1061         target.detachTo (values.appendedRaw());
     1090        Bstr("TargetAddress").detachTo(names.appendedRaw());
     1091        server.detachTo(values.appendedRaw());
     1092        Bstr("TargetName").detachTo(names.appendedRaw());
     1093        target.detachTo(values.appendedRaw());
    10621094
    10631095        if (!lun.isEmpty())
    10641096        {
    1065             Bstr ("LUN").detachTo (names.appendedRaw());
    1066             lun.detachTo (values.appendedRaw());
     1097            Bstr("LUN").detachTo(names.appendedRaw());
     1098            lun.detachTo(values.appendedRaw());
    10671099        }
    10681100        if (!username.isEmpty())
    10691101        {
    1070             Bstr ("InitiatorUsername").detachTo (names.appendedRaw());
    1071             username.detachTo (values.appendedRaw());
     1102            Bstr("InitiatorUsername").detachTo(names.appendedRaw());
     1103            username.detachTo(values.appendedRaw());
    10721104        }
    10731105        if (!password.isEmpty())
    10741106        {
    1075             Bstr ("InitiatorSecret").detachTo (names.appendedRaw());
    1076             password.detachTo (values.appendedRaw());
     1107            Bstr("InitiatorSecret").detachTo(names.appendedRaw());
     1108            password.detachTo(values.appendedRaw());
    10771109        }
    10781110
    … …  
    10811113        // value does more harm than good, as the initiator name is supposed
    10821114        // to identify a particular initiator uniquely.
    1083 //        Bstr ("InitiatorName").detachTo (names.appendedRaw());
    1084 //        Bstr ("iqn.2008-04.com.sun.virtualbox.initiator").detachTo (values.appendedRaw());
     1115//        Bstr("InitiatorName").detachTo(names.appendedRaw());
     1116//        Bstr("iqn.2008-04.com.sun.virtualbox.initiator").detachTo(values.appendedRaw());
    10851117
    10861118        /// @todo add --targetName and --targetPassword options
    … …  
    10881120        if (fIntNet)
    10891121        {
    1090             Bstr ("HostIPStack").detachTo (names.appendedRaw());
    1091             Bstr ("0").detachTo (values.appendedRaw());
    1092         }
    1093 
    1094         CHECK_ERROR_BREAK (hardDisk,
    1095             SetProperties (ComSafeArrayAsInParam (names),
    1096                            ComSafeArrayAsInParam (values)));
     1122            Bstr("HostIPStack").detachTo(names.appendedRaw());
     1123            Bstr("0").detachTo(values.appendedRaw());
     1124        }
     1125
     1126        CHECK_ERROR_BREAK(hardDisk, SetProperties(ComSafeArrayAsInParam(names),
     1127                                                  ComSafeArrayAsInParam(values)));
    10971128
    10981129        if (DiskType != MediumType_Normal)
    … …  
    11611192    bool unknown = false;
    11621193    /* first guess is that it's a UUID */
    1163     rc = a->virtualBox->FindMedium(Bstr(FilenameOrUuid), DeviceType_HardDisk, hardDisk.asOutParam());
     1194    rc = a->virtualBox->FindMedium(Bstr(FilenameOrUuid).raw(),
     1195                                   DeviceType_HardDisk,
     1196                                   hardDisk.asOutParam());
    11641197    /* no? well, then it's an unkwnown image */
    1165     if (FAILED (rc))
    1166     {
    1167         rc = a->virtualBox->OpenMedium(Bstr(FilenameOrUuid), DeviceType_HardDisk, AccessMode_ReadWrite, hardDisk.asOutParam());
     1198    if (FAILED(rc))
     1199    {
     1200        rc = a->virtualBox->OpenMedium(Bstr(FilenameOrUuid).raw(),
     1201                                       DeviceType_HardDisk,
     1202                                       AccessMode_ReadWrite,
     1203                                       hardDisk.asOutParam());
    11681204        if (rc == VBOX_E_FILE_ERROR)
    11691205        {
    … …  
    11751211                return 1;
    11761212            }
    1177             CHECK_ERROR(a->virtualBox, OpenMedium(Bstr(szFilenameAbs), DeviceType_HardDisk, AccessMode_ReadWrite, hardDisk.asOutParam()));
    1178         }
    1179         if (SUCCEEDED (rc))
     1213            CHECK_ERROR(a->virtualBox, OpenMedium(Bstr(szFilenameAbs).raw(),
     1214                                                  DeviceType_HardDisk,
     1215                                                  AccessMode_ReadWrite,
     1216                                                  hardDisk.asOutParam()));
     1217        }
     1218        if (SUCCEEDED(rc))
    11801219            unknown = true;
    11811220    }
    … …  
    11931232        /// @todo NEWMEDIA print the full state value
    11941233        MediumState_T state;
    1195         CHECK_ERROR_BREAK (hardDisk, RefreshState(&state));
     1234        CHECK_ERROR_BREAK(hardDisk, RefreshState(&state));
    11961235        RTPrintf("Accessible:           %s\n", state != MediumState_Inaccessible ? "yes" : "no");
    11971236
    … …  
    11991238        {
    12001239            Bstr err;
    1201             CHECK_ERROR_BREAK (hardDisk, COMGETTER(LastAccessError)(err.asOutParam()));
     1240            CHECK_ERROR_BREAK(hardDisk, COMGETTER(LastAccessError)(err.asOutParam()));
    12021241            RTPrintf("Access Error:         %lS\n", err.raw());
    12031242        }
    … …  
    12051244        Bstr description;
    12061245        hardDisk->COMGETTER(Description)(description.asOutParam());
    1207         if (description)
     1246        if (!description.isEmpty())
    12081247        {
    12091248            RTPrintf("Description:          %lS\n", description.raw());
    … …  
    12181257
    12191258        ComPtr <IMedium> parent;
    1220         hardDisk->COMGETTER(Parent) (parent.asOutParam());
     1259        hardDisk->COMGETTER(Parent)(parent.asOutParam());
    12211260
    12221261        MediumType_T type;
    … …  
    14021441
    14031442    ComPtr<IMedium> pMedium;
    1404     rc = a->virtualBox->OpenMedium(Bstr(Filename), devType, AccessMode_ReadWrite, pMedium.asOutParam());
     1443    rc = a->virtualBox->OpenMedium(Bstr(Filename).raw(), devType,
     1444                                   AccessMode_ReadWrite, pMedium.asOutParam());
    14051445    if (rc == VBOX_E_FILE_ERROR)
    14061446    {
    … …  
    14121452            return 1;
    14131453        }
    1414         CHECK_ERROR(a->virtualBox, OpenMedium(Bstr(szFilenameAbs), devType, AccessMode_ReadWrite, pMedium.asOutParam()));
     1454        CHECK_ERROR(a->virtualBox, OpenMedium(Bstr(szFilenameAbs).raw(),
     1455                                              devType, AccessMode_ReadWrite,
     1456                                              pMedium.asOutParam()));
    14151457    }
    14161458    if (SUCCEEDED(rc) && pMedium)
    … …  
    14331475            Bstr ImageIdStr = BstrFmt("%RTuuid", &ImageId);
    14341476            Bstr ParentIdStr = BstrFmt("%RTuuid", &ParentId);
    1435             CHECK_ERROR(pMedium, SetIDs(fSetImageId, ImageIdStr, fSetParentId, ParentIdStr));
     1477            CHECK_ERROR(pMedium, SetIDs(fSetImageId, ImageIdStr.raw(),
     1478                                        fSetParentId, ParentIdStr.raw()));
    14361479        }
    14371480    }
    … …  
    15251568
    15261569    if (cmd == CMD_DISK)
    1527         CHECK_ERROR(a->virtualBox, FindMedium(Bstr(FilenameOrUuid), DeviceType_HardDisk, medium.asOutParam()));
     1570        CHECK_ERROR(a->virtualBox, FindMedium(Bstr(FilenameOrUuid).raw(),
     1571                                              DeviceType_HardDisk,
     1572                                              medium.asOutParam()));
    15281573    else if (cmd == CMD_DVD)
    1529         CHECK_ERROR(a->virtualBox, FindMedium(Bstr(FilenameOrUuid), DeviceType_DVD, medium.asOutParam()));
     1574        CHECK_ERROR(a->virtualBox, FindMedium(Bstr(FilenameOrUuid).raw(),
     1575                                              DeviceType_DVD,
     1576                                              medium.asOutParam()));
    15301577    else if (cmd == CMD_FLOPPY)
    1531         CHECK_ERROR(a->virtualBox, FindMedium(Bstr(FilenameOrUuid), DeviceType_Floppy, medium.asOutParam()));
     1578        CHECK_ERROR(a->virtualBox, FindMedium(Bstr(FilenameOrUuid).raw(),
     1579                                              DeviceType_Floppy,
     1580                                              medium.asOutParam()));
    15321581
    15331582    if (SUCCEEDED(rc) && medium)

  • trunk/src/VBox/Frontends/VBoxManage/VBoxManageGuestCtrl.cpp

    r32712 r32718  
    131131    Utf8Str Utf8Cmd(a->argv[1]);
    132132    uint32_t uFlags = 0;
    133     com::SafeArray <BSTR> args;
    134     com::SafeArray <BSTR> env;
     133    com::SafeArray<CBSTR> args;
     134    com::SafeArray<CBSTR> env;
    135135    Utf8Str Utf8UserName;
    136136    Utf8Str Utf8Password;
    … …  
    143143
    144144    /* Always use the actual command line as argv[0]. */
    145     args.push_back(Bstr(Utf8Cmd));
     145    args.push_back(Bstr(Utf8Cmd).raw());
    146146
    147147    /* Iterate through all possible commands (if available). */
    … …  
    164164                {
    165165                    for (int j = 0; j < cArgs; j++)
    166                         args.push_back(Bstr(papszArg[j]));
     166                        args.push_back(Bstr(papszArg[j]).raw());
    167167
    168168                    RTGetOptArgvFree(papszArg);
    … …  
    185185                {
    186186                    for (int j = 0; j < cArgs; j++)
    187                         env.push_back(Bstr(papszArg[j]));
     187                        env.push_back(Bstr(papszArg[j]).raw());
    188188
    189189                    RTGetOptArgvFree(papszArg);
    … …  
    277277    ComPtr<IMachine> machine;
    278278    /* assume it's an UUID */
    279     HRESULT rc = a->virtualBox->GetMachine(Bstr(a->argv[0]), machine.asOutParam());
     279    HRESULT rc = a->virtualBox->GetMachine(Bstr(a->argv[0]).raw(),
     280                                           machine.asOutParam());
    280281    if (FAILED(rc) || !machine)
    281282    {
    282283        /* must be a name */
    283         CHECK_ERROR(a->virtualBox, FindMachine(Bstr(a->argv[0]), machine.asOutParam()));
     284        CHECK_ERROR(a->virtualBox, FindMachine(Bstr(a->argv[0]).raw(),
     285                                               machine.asOutParam()));
    284286    }
    285287
    … …  
    317319
    318320            /* Execute the process. */
    319             rc = guest->ExecuteProcess(Bstr(Utf8Cmd), uFlags,
    320                                        ComSafeArrayAsInParam(args), ComSafeArrayAsInParam(env),
    321                                        Bstr(Utf8UserName), Bstr(Utf8Password), u32TimeoutMS,
     321            rc = guest->ExecuteProcess(Bstr(Utf8Cmd).raw(), uFlags,
     322                                       ComSafeArrayAsInParam(args),
     323                                       ComSafeArrayAsInParam(env),
     324                                       Bstr(Utf8UserName).raw(),
     325                                       Bstr(Utf8Password).raw(), u32TimeoutMS,
    322326                                       &uPID, progress.asOutParam());
    323327            if (FAILED(rc))

  • trunk/src/VBox/Frontends/VBoxManage/VBoxManageGuestProp.cpp

    r32712 r32718  
    8989    ComPtr<IMachine> machine;
    9090    /* assume it's a UUID */
    91     rc = a->virtualBox->GetMachine(Bstr(a->argv[0]), machine.asOutParam());
     91    rc = a->virtualBox->GetMachine(Bstr(a->argv[0]).raw(),
     92                                   machine.asOutParam());
    9293    if (FAILED(rc) || !machine)
    9394    {
    9495        /* must be a name */
    95         CHECK_ERROR(a->virtualBox, FindMachine(Bstr(a->argv[0]), machine.asOutParam()));
     96        CHECK_ERROR(a->virtualBox, FindMachine(Bstr(a->argv[0]).raw(),
     97                                               machine.asOutParam()));
    9698    }
    9799    if (machine)
    … …  
    106108        LONG64 i64Timestamp;
    107109        Bstr flags;
    108         CHECK_ERROR(machine, GetGuestProperty(Bstr(a->argv[1]), value.asOutParam(),
     110        CHECK_ERROR(machine, GetGuestProperty(Bstr(a->argv[1]).raw(),
     111                                              value.asOutParam(),
    109112                                              &i64Timestamp, flags.asOutParam()));
    110         if (!value)
     113        if (value.isEmpty())
    111114            RTPrintf("No value set!\n");
    112         if (value)
     115        else
    113116            RTPrintf("Value: %lS\n", value.raw());
    114         if (value && verbose)
     117        if (!value.isEmpty() && verbose)
    115118        {
    116119            RTPrintf("Timestamp: %lld\n", i64Timestamp);
    … …  
    154157    ComPtr<IMachine> machine;
    155158    /* assume it's a UUID */
    156     rc = a->virtualBox->GetMachine(Bstr(a->argv[0]), machine.asOutParam());
     159    rc = a->virtualBox->GetMachine(Bstr(a->argv[0]).raw(),
     160                                   machine.asOutParam());
    157161    if (FAILED(rc) || !machine)
    158162    {
    159163        /* must be a name */
    160         CHECK_ERROR(a->virtualBox, FindMachine(Bstr(a->argv[0]), machine.asOutParam()));
     164        CHECK_ERROR(a->virtualBox, FindMachine(Bstr(a->argv[0]).raw(),
     165                                               machine.asOutParam()));
    161166    }
    162167    if (machine)
    … …  
    169174
    170175        if (!pszValue && !pszFlags)
    171             CHECK_ERROR(machine, SetGuestPropertyValue(Bstr(pszName), Bstr("")));
     176            CHECK_ERROR(machine, SetGuestPropertyValue(Bstr(pszName).raw(),
     177                                                       Bstr().raw()));
    172178        else if (!pszFlags)
    173             CHECK_ERROR(machine, SetGuestPropertyValue(Bstr(pszName), Bstr(pszValue)));
     179            CHECK_ERROR(machine, SetGuestPropertyValue(Bstr(pszName).raw(),
     180                                                       Bstr(pszValue).raw()));
    174181        else
    175             CHECK_ERROR(machine, SetGuestProperty(Bstr(pszName), Bstr(pszValue), Bstr(pszFlags)));
     182            CHECK_ERROR(machine, SetGuestProperty(Bstr(pszName).raw(),
     183                                                  Bstr(pszValue).raw(),
     184                                                  Bstr(pszFlags).raw()));
    176185
    177186        if (SUCCEEDED(rc))
    … …  
    214223    ComPtr<IMachine> machine;
    215224    /* assume it's a UUID */
    216     HRESULT rc = a->virtualBox->GetMachine(Bstr(a->argv[0]), machine.asOutParam());
     225    HRESULT rc = a->virtualBox->GetMachine(Bstr(a->argv[0]).raw(),
     226                                           machine.asOutParam());
    217227    if (FAILED(rc) || !machine)
    218228    {
    219229        /* must be a name */
    220         CHECK_ERROR(a->virtualBox, FindMachine(Bstr(a->argv[0]), machine.asOutParam()));
     230        CHECK_ERROR(a->virtualBox, FindMachine(Bstr(a->argv[0]).raw(),
     231                                               machine.asOutParam()));
    221232    }
    222233    if (machine)
    … …  
    232243        com::SafeArray<LONG64> timestamps;
    233244        com::SafeArray<BSTR> flags;
    234         CHECK_ERROR(machine, EnumerateGuestProperties(Bstr(Utf8Patterns),
     245        CHECK_ERROR(machine, EnumerateGuestProperties(Bstr(Utf8Patterns).raw(),
    235246                                                      ComSafeArrayAsOutParam(names),
    236247                                                      ComSafeArrayAsOutParam(values),
    … …  
    270281    ComPtr<IMachine> machine;
    271282    /* assume it's a UUID */
    272     HRESULT rc = a->virtualBox->GetMachine(Bstr(a->argv[0]), machine.asOutParam());
     283    HRESULT rc = a->virtualBox->GetMachine(Bstr(a->argv[0]).raw(),
     284                                           machine.asOutParam());
    273285    if (FAILED(rc) || !machine)
    274286    {
    275287        /* must be a name */
    276         CHECK_ERROR(a->virtualBox, FindMachine(Bstr(a->argv[0]), machine.asOutParam()));
     288        CHECK_ERROR(a->virtualBox, FindMachine(Bstr(a->argv[0]).raw(),
     289                                               machine.asOutParam()));
    277290    }
    278291    if (!machine)

  • trunk/src/VBox/Frontends/VBoxManage/VBoxManageHostonly.cpp

    r32701 r32718  
    234234
    235235    ComPtr<IHostNetworkInterface> hif;
    236     CHECK_ERROR(host, FindHostNetworkInterfaceByName(name, hif.asOutParam()));
     236    CHECK_ERROR(host, FindHostNetworkInterfaceByName(name.raw(),
     237                                                     hif.asOutParam()));
    237238
    238239    if (FAILED(rc))
    … …  
    248249            pNetmask = "255.255.255.0"; /* ?? */
    249250
    250         CHECK_ERROR(hif, EnableStaticIpConfig(Bstr(pIp), Bstr(pNetmask)));
     251        CHECK_ERROR(hif, EnableStaticIpConfig(Bstr(pIp).raw(),
     252                                              Bstr(pNetmask).raw()));
    251253    }
    252254    else if (pIpv6)
    … …  
    265267
    266268        Bstr ipv6str(pIpv6);
    267         CHECK_ERROR(hif, EnableStaticIpConfigV6(ipv6str, (ULONG)uNetmasklengthv6));
     269        CHECK_ERROR(hif, EnableStaticIpConfigV6(ipv6str.raw(),
     270                                                (ULONG)uNetmasklengthv6));
    268271    }
    269272    else

  • trunk/src/VBox/Frontends/VBoxManage/VBoxManageImport.cpp

    r32701 r32718  
    248248            pszAbsFilePath = RTPathAbsDup(strOvfFilename.c_str());
    249249        ComPtr<IProgress> progressRead;
    250         CHECK_ERROR_BREAK(pAppliance, Read(Bstr(pszAbsFilePath), progressRead.asOutParam()));
     250        CHECK_ERROR_BREAK(pAppliance, Read(Bstr(pszAbsFilePath).raw(),
     251                                           progressRead.asOutParam()));
    251252        RTStrFree(pszAbsFilePath);
    252253
    … …  
    831832                    ComPtr<IMachine> machine;
    832833                    /* assume it's a UUID */
    833                     rc = a->virtualBox->GetMachine(Bstr(strMachine), machine.asOutParam());
     834                    rc = a->virtualBox->GetMachine(Bstr(strMachine).raw(),
     835                                                   machine.asOutParam());
    834836                    if (FAILED(rc) || !machine)
    835837                    {
    836838                        /* must be a name */
    837                         CHECK_ERROR_BREAK(a->virtualBox, FindMachine(Bstr(strMachine), machine.asOutParam()));
     839                        CHECK_ERROR_BREAK(a->virtualBox, FindMachine(Bstr(strMachine).raw(),
     840                                                                     machine.asOutParam()));
    838841                    }
    839842
    … …  
    910913                {
    911914                    if (itD->first == "product")
    912                         pVSD->AddDescription (VirtualSystemDescriptionType_Product, Bstr(itD->second), Bstr(itD->second));
     915                        pVSD->AddDescription(VirtualSystemDescriptionType_Product,
     916                                             Bstr(itD->second).raw(),
     917                                             Bstr(itD->second).raw());
    913918                    else if (itD->first == "producturl")
    914                         pVSD->AddDescription (VirtualSystemDescriptionType_ProductUrl, Bstr(itD->second), Bstr(itD->second));
     919                        pVSD->AddDescription(VirtualSystemDescriptionType_ProductUrl,
     920                                             Bstr(itD->second).raw(),
     921                                             Bstr(itD->second).raw());
    915922                    else if (itD->first == "vendor")
    916                         pVSD->AddDescription (VirtualSystemDescriptionType_Vendor, Bstr(itD->second), Bstr(itD->second));
     923                        pVSD->AddDescription(VirtualSystemDescriptionType_Vendor,
     924                                             Bstr(itD->second).raw(),
     925                                             Bstr(itD->second).raw());
    917926                    else if (itD->first == "vendorurl")
    918                         pVSD->AddDescription (VirtualSystemDescriptionType_VendorUrl, Bstr(itD->second), Bstr(itD->second));
     927                        pVSD->AddDescription(VirtualSystemDescriptionType_VendorUrl,
     928                                             Bstr(itD->second).raw(),
     929                                             Bstr(itD->second).raw());
    919930                    else if (itD->first == "version")
    920                         pVSD->AddDescription (VirtualSystemDescriptionType_Version, Bstr(itD->second), Bstr(itD->second));
     931                        pVSD->AddDescription(VirtualSystemDescriptionType_Version,
     932                                             Bstr(itD->second).raw(),
     933                                             Bstr(itD->second).raw());
    921934                    else if (itD->first == "eula")
    922                         pVSD->AddDescription (VirtualSystemDescriptionType_License, Bstr(itD->second), Bstr(itD->second));
     935                        pVSD->AddDescription(VirtualSystemDescriptionType_License,
     936                                             Bstr(itD->second).raw(),
     937                                             Bstr(itD->second).raw());
    923938                    else if (itD->first == "eulafile")
    924939                    {
    … …  
    930945                        {
    931946                            Bstr bstrContent((char*)pvFile);
    932                             pVSD->AddDescription(VirtualSystemDescriptionType_License, bstrContent, bstrContent);
     947                            pVSD->AddDescription(VirtualSystemDescriptionType_License,
     948                                                 bstrContent.raw(),
     949                                                 bstrContent.raw());
    933950                            RTFileReadAllFree(pvFile, cbFile);
    934951                        }
    … …  
    955972        else
    956973            pszAbsFilePath = RTPathAbsDup(strOutputFile.c_str());
    957         CHECK_ERROR_BREAK(pAppliance, Write(Bstr(strOvfFormat), fManifest, Bstr(pszAbsFilePath), progress.asOutParam()));
     974        CHECK_ERROR_BREAK(pAppliance, Write(Bstr(strOvfFormat).raw(),
     975                                            fManifest,
     976                                            Bstr(pszAbsFilePath).raw(),
     977                                            progress.asOutParam()));
    958978        RTStrFree(pszAbsFilePath);
    959979

  • trunk/src/VBox/Frontends/VBoxManage/VBoxManageInfo.cpp

    r32701 r32718  
    9797}
    9898
    99 static void makeTimeStr (char *s, int cb, int64_t millies)
     99static void makeTimeStr(char *s, int cb, int64_t millies)
    100100{
    101101    RTTIME t;
    … …  
    104104    RTTimeSpecSetMilli(&ts, millies);
    105105
    106     RTTimeExplode (&t, &ts);
     106    RTTimeExplode(&t, &ts);
    107107
    108108    RTStrPrintf(s, cb, "%04d/%02d/%02d %02d:%02d:%02d UTC",
    … …  
    119119#endif
    120120
    121 HRESULT showVMInfo (ComPtr<IVirtualBox> virtualBox,
    122                     ComPtr<IMachine> machine,
    123                     VMINFO_DETAILS details /*= VMINFO_NONE*/,
    124                     ComPtr<IConsole> console /*= ComPtr <IConsole> ()*/)
     121HRESULT showVMInfo(ComPtr<IVirtualBox> virtualBox,
     122                   ComPtr<IMachine> machine,
     123                   VMINFO_DETAILS details /*= VMINFO_NONE*/,
     124                   ComPtr<IConsole> console /*= ComPtr <IConsole> ()*/)
    125125{
    126126    HRESULT rc;
    … …  
    195195    rc = machine->COMGETTER(OSTypeId)(osTypeId.asOutParam());
    196196    ComPtr<IGuestOSType> osType;
    197     rc = virtualBox->GetGuestOSType (osTypeId, osType.asOutParam());
     197    rc = virtualBox->GetGuestOSType(osTypeId.raw(), osType.asOutParam());
    198198    Bstr osName;
    199199    rc = osType->COMGETTER(Description)(osName.asOutParam());
    … …  
    592592     */
    593593    com::SafeIfaceArray<IStorageController> storageCtls;
    594     CHECK_ERROR(machine, COMGETTER(StorageControllers)(ComSafeArrayAsOutParam (storageCtls)));
     594    CHECK_ERROR(machine, COMGETTER(StorageControllers)(ComSafeArrayAsOutParam(storageCtls)));
    595595    for (size_t i = 0; i < storageCtls.size(); ++ i)
    596596    {
    … …  
    676676            for (ULONG k = 0; k < cDevices; ++ k)
    677677            {
    678                 rc = machine->GetMedium(storageCtlName, i, k, medium.asOutParam());
     678                rc = machine->GetMedium(storageCtlName.raw(), i, k,
     679                                        medium.asOutParam());
    679680                if (SUCCEEDED(rc) && medium)
    680681                {
    … …  
    682683                    ComPtr<IMediumAttachment> mediumAttach;
    683684
    684                     rc = machine->GetMediumAttachment(storageCtlName, i, k, mediumAttach.asOutParam());
     685                    rc = machine->GetMediumAttachment(storageCtlName.raw(),
     686                                                      i, k,
     687                                                      mediumAttach.asOutParam());
    685688                    if (SUCCEEDED(rc) && mediumAttach)
    686689                        mediumAttach->COMGETTER(Passthrough)(&fPassthrough);
    … …  
    12921295        {
    12931296            ULONG xRes, yRes, bpp;
    1294             rc = display->GetScreenResolution (0, &xRes, &yRes, &bpp);
     1297            rc = display->GetScreenResolution(0, &xRes, &yRes, &bpp);
    12951298            if (rc == E_ACCESSDENIED)
    12961299                break; /* VM not powered up */
    … …  
    14421445
    14431446                    BOOL bActive = FALSE;
    1444                     CHECK_ERROR_RET (DevPtr, COMGETTER (Active) (&bActive), rc);
     1447                    CHECK_ERROR_RET(DevPtr, COMGETTER(Active)(&bActive), rc);
    14451448                    if (details == VMINFO_MACHINEREADABLE)
    14461449                        RTPrintf("USBFilterActive%zu=\"%s\"\n", index + 1, bActive ? "on" : "off");
    … …  
    14491452
    14501453                    Bstr bstr;
    1451                     CHECK_ERROR_RET (DevPtr, COMGETTER (Name) (bstr.asOutParam()), rc);
     1454                    CHECK_ERROR_RET(DevPtr, COMGETTER(Name)(bstr.asOutParam()), rc);
    14521455                    if (details == VMINFO_MACHINEREADABLE)
    14531456                        RTPrintf("USBFilterName%zu=\"%lS\"\n", index + 1, bstr.raw());
    14541457                    else
    14551458                        RTPrintf("Name:             %lS\n", bstr.raw());
    1456                     CHECK_ERROR_RET (DevPtr, COMGETTER (VendorId) (bstr.asOutParam()), rc);
     1459                    CHECK_ERROR_RET(DevPtr, COMGETTER(VendorId)(bstr.asOutParam()), rc);
    14571460                    if (details == VMINFO_MACHINEREADABLE)
    14581461                        RTPrintf("USBFilterVendorId%zu=\"%lS\"\n", index + 1, bstr.raw());
    14591462                    else
    14601463                        RTPrintf("VendorId:         %lS\n", bstr.raw());
    1461                     CHECK_ERROR_RET (DevPtr, COMGETTER (ProductId) (bstr.asOutParam()), rc);
     1464                    CHECK_ERROR_RET(DevPtr, COMGETTER(ProductId)(bstr.asOutParam()), rc);
    14621465                    if (details == VMINFO_MACHINEREADABLE)
    14631466                        RTPrintf("USBFilterProductId%zu=\"%lS\"\n", index + 1, bstr.raw());
    14641467                    else
    14651468                        RTPrintf("ProductId:        %lS\n", bstr.raw());
    1466                     CHECK_ERROR_RET (DevPtr, COMGETTER (Revision) (bstr.asOutParam()), rc);
     1469                    CHECK_ERROR_RET(DevPtr, COMGETTER(Revision)(bstr.asOutParam()), rc);
    14671470                    if (details == VMINFO_MACHINEREADABLE)
    14681471                        RTPrintf("USBFilterRevision%zu=\"%lS\"\n", index + 1, bstr.raw());
    14691472                    else
    14701473                        RTPrintf("Revision:         %lS\n", bstr.raw());
    1471                     CHECK_ERROR_RET (DevPtr, COMGETTER (Manufacturer) (bstr.asOutParam()), rc);
     1474                    CHECK_ERROR_RET(DevPtr, COMGETTER(Manufacturer)(bstr.asOutParam()), rc);
    14721475                    if (details == VMINFO_MACHINEREADABLE)
    14731476                        RTPrintf("USBFilterManufacturer%zu=\"%lS\"\n", index + 1, bstr.raw());
    14741477                    else
    14751478                        RTPrintf("Manufacturer:     %lS\n", bstr.raw());
    1476                     CHECK_ERROR_RET (DevPtr, COMGETTER (Product) (bstr.asOutParam()), rc);
     1479                    CHECK_ERROR_RET(DevPtr, COMGETTER(Product)(bstr.asOutParam()), rc);
    14771480                    if (details == VMINFO_MACHINEREADABLE)
    14781481                        RTPrintf("USBFilterProduct%zu=\"%lS\"\n", index + 1, bstr.raw());
    14791482                    else
    14801483                        RTPrintf("Product:          %lS\n", bstr.raw());
    1481                     CHECK_ERROR_RET (DevPtr, COMGETTER (Remote) (bstr.asOutParam()), rc);
     1484                    CHECK_ERROR_RET(DevPtr, COMGETTER(Remote)(bstr.asOutParam()), rc);
    14821485                    if (details == VMINFO_MACHINEREADABLE)
    14831486                        RTPrintf("USBFilterRemote%zu=\"%lS\"\n", index + 1, bstr.raw());
    14841487                    else
    14851488                        RTPrintf("Remote:           %lS\n", bstr.raw());
    1486                     CHECK_ERROR_RET (DevPtr, COMGETTER (SerialNumber) (bstr.asOutParam()), rc);
     1489                    CHECK_ERROR_RET(DevPtr, COMGETTER(SerialNumber)(bstr.asOutParam()), rc);
    14871490                    if (details == VMINFO_MACHINEREADABLE)
    14881491                        RTPrintf("USBFilterSerialNumber%zu=\"%lS\"\n", index + 1, bstr.raw());
    … …  
    14921495                    {
    14931496                        ULONG fMaskedIfs;
    1494                         CHECK_ERROR_RET (DevPtr, COMGETTER (MaskedInterfaces) (&fMaskedIfs), rc);
     1497                        CHECK_ERROR_RET(DevPtr, COMGETTER(MaskedInterfaces)(&fMaskedIfs), rc);
    14951498                        if (fMaskedIfs)
    14961499                            RTPrintf("Masked Interfaces: %#010x\n", fMaskedIfs);
    … …  
    15091512
    15101513                SafeIfaceArray <IHostUSBDevice> coll;
    1511                 CHECK_ERROR_RET (console, COMGETTER(RemoteUSBDevices) (ComSafeArrayAsOutParam(coll)), rc);
     1514                CHECK_ERROR_RET(console, COMGETTER(RemoteUSBDevices)(ComSafeArrayAsOutParam(coll)), rc);
    15121515
    15131516                if (coll.size() == 0)
    … …  
    15241527                        /* Query info. */
    15251528                        Bstr id;
    1526                         CHECK_ERROR_RET (dev, COMGETTER(Id)(id.asOutParam()), rc);
     1529                        CHECK_ERROR_RET(dev, COMGETTER(Id)(id.asOutParam()), rc);
    15271530                        USHORT usVendorId;
    1528                         CHECK_ERROR_RET (dev, COMGETTER(VendorId)(&usVendorId), rc);
     1531                        CHECK_ERROR_RET(dev, COMGETTER(VendorId)(&usVendorId), rc);
    15291532                        USHORT usProductId;
    1530                         CHECK_ERROR_RET (dev, COMGETTER(ProductId)(&usProductId), rc);
     1533                        CHECK_ERROR_RET(dev, COMGETTER(ProductId)(&usProductId), rc);
    15311534                        USHORT bcdRevision;
    1532                         CHECK_ERROR_RET (dev, COMGETTER(Revision)(&bcdRevision), rc);
     1535                        CHECK_ERROR_RET(dev, COMGETTER(Revision)(&bcdRevision), rc);
    15331536
    15341537                        if (details == VMINFO_MACHINEREADABLE)
    … …  
    15531556                        /* optional stuff. */
    15541557                        Bstr bstr;
    1555                         CHECK_ERROR_RET (dev, COMGETTER(Manufacturer)(bstr.asOutParam()), rc);
     1558                        CHECK_ERROR_RET(dev, COMGETTER(Manufacturer)(bstr.asOutParam()), rc);
    15561559                        if (!bstr.isEmpty())
    15571560                        {
    … …  
    15611564                                RTPrintf("Manufacturer:       %lS\n", bstr.raw());
    15621565                        }
    1563                         CHECK_ERROR_RET (dev, COMGETTER(Product)(bstr.asOutParam()), rc);
     1566                        CHECK_ERROR_RET(dev, COMGETTER(Product)(bstr.asOutParam()), rc);
    15641567                        if (!bstr.isEmpty())
    15651568                        {
    … …  
    15691572                                RTPrintf("Product:            %lS\n", bstr.raw());
    15701573                        }
    1571                         CHECK_ERROR_RET (dev, COMGETTER(SerialNumber)(bstr.asOutParam()), rc);
     1574                        CHECK_ERROR_RET(dev, COMGETTER(SerialNumber)(bstr.asOutParam()), rc);
    15721575                        if (!bstr.isEmpty())
    15731576                        {
    … …  
    15771580                                RTPrintf("SerialNumber:       %lS\n", bstr.raw());
    15781581                        }
    1579                         CHECK_ERROR_RET (dev, COMGETTER(Address)(bstr.asOutParam()), rc);
     1582                        CHECK_ERROR_RET(dev, COMGETTER(Address)(bstr.asOutParam()), rc);
    15801583                        if (!bstr.isEmpty())
    15811584                        {
    … …  
    15951598            {
    15961599                if (details != VMINFO_MACHINEREADABLE)
    1597                     RTPrintf ("Currently Attached USB Devices:\n\n");
     1600                    RTPrintf("Currently Attached USB Devices:\n\n");
    15981601
    15991602                SafeIfaceArray <IUSBDevice> coll;
    1600                 CHECK_ERROR_RET (console, COMGETTER(USBDevices) (ComSafeArrayAsOutParam(coll)), rc);
     1603                CHECK_ERROR_RET(console, COMGETTER(USBDevices)(ComSafeArrayAsOutParam(coll)), rc);
    16011604
    16021605                if (coll.size() == 0)
    … …  
    16131616                        /* Query info. */
    16141617                        Bstr id;
    1615                         CHECK_ERROR_RET (dev, COMGETTER(Id)(id.asOutParam()), rc);
     1618                        CHECK_ERROR_RET(dev, COMGETTER(Id)(id.asOutParam()), rc);
    16161619                        USHORT usVendorId;
    1617                         CHECK_ERROR_RET (dev, COMGETTER(VendorId)(&usVendorId), rc);
     1620                        CHECK_ERROR_RET(dev, COMGETTER(VendorId)(&usVendorId), rc);
    16181621                        USHORT usProductId;
    1619                         CHECK_ERROR_RET (dev, COMGETTER(ProductId)(&usProductId), rc);
     1622                        CHECK_ERROR_RET(dev, COMGETTER(ProductId)(&usProductId), rc);
    16201623                        USHORT bcdRevision;
    1621                         CHECK_ERROR_RET (dev, COMGETTER(Revision)(&bcdRevision), rc);
     1624                        CHECK_ERROR_RET(dev, COMGETTER(Revision)(&bcdRevision), rc);
    16221625
    16231626                        if (details == VMINFO_MACHINEREADABLE)
    … …  
    16421645                        /* optional stuff. */
    16431646                        Bstr bstr;
    1644                         CHECK_ERROR_RET (dev, COMGETTER(Manufacturer)(bstr.asOutParam()), rc);
     1647                        CHECK_ERROR_RET(dev, COMGETTER(Manufacturer)(bstr.asOutParam()), rc);
    16451648                        if (!bstr.isEmpty())
    16461649                        {
    … …  
    16501653                                RTPrintf("Manufacturer:       %lS\n", bstr.raw());
    16511654                        }
    1652                         CHECK_ERROR_RET (dev, COMGETTER(Product)(bstr.asOutParam()), rc);
     1655                        CHECK_ERROR_RET(dev, COMGETTER(Product)(bstr.asOutParam()), rc);
    16531656                        if (!bstr.isEmpty())
    16541657                        {
    … …  
    16581661                                RTPrintf("Product:            %lS\n", bstr.raw());
    16591662                        }
    1660                         CHECK_ERROR_RET (dev, COMGETTER(SerialNumber)(bstr.asOutParam()), rc);
     1663                        CHECK_ERROR_RET(dev, COMGETTER(SerialNumber)(bstr.asOutParam()), rc);
    16611664                        if (!bstr.isEmpty())
    16621665                        {
    … …  
    16661669                                RTPrintf("SerialNumber:       %lS\n", bstr.raw());
    16671670                        }
    1668                         CHECK_ERROR_RET (dev, COMGETTER(Address)(bstr.asOutParam()), rc);
     1671                        CHECK_ERROR_RET(dev, COMGETTER(Address)(bstr.asOutParam()), rc);
    16691672                        if (!bstr.isEmpty())
    16701673                        {
    … …  
    17901793        ULONG   EncryptionStyle;
    17911794
    1792         CHECK_ERROR_RET(remoteDisplayInfo, COMGETTER(Active)             (&Active), rc);
    1793         CHECK_ERROR_RET(remoteDisplayInfo, COMGETTER(NumberOfClients)    (&NumberOfClients), rc);
    1794         CHECK_ERROR_RET(remoteDisplayInfo, COMGETTER(BeginTime)          (&BeginTime), rc);
    1795         CHECK_ERROR_RET(remoteDisplayInfo, COMGETTER(EndTime)            (&EndTime), rc);
    1796         CHECK_ERROR_RET(remoteDisplayInfo, COMGETTER(BytesSent)          (&BytesSent), rc);
    1797         CHECK_ERROR_RET(remoteDisplayInfo, COMGETTER(BytesSentTotal)     (&BytesSentTotal), rc);
    1798         CHECK_ERROR_RET(remoteDisplayInfo, COMGETTER(BytesReceived)      (&BytesReceived), rc);
    1799         CHECK_ERROR_RET(remoteDisplayInfo, COMGETTER(BytesReceivedTotal) (&BytesReceivedTotal), rc);
    1800         CHECK_ERROR_RET(remoteDisplayInfo, COMGETTER(User)               (User.asOutParam ()), rc);
    1801         CHECK_ERROR_RET(remoteDisplayInfo, COMGETTER(Domain)             (Domain.asOutParam ()), rc);
    1802         CHECK_ERROR_RET(remoteDisplayInfo, COMGETTER(ClientName)         (ClientName.asOutParam ()), rc);
    1803         CHECK_ERROR_RET(remoteDisplayInfo, COMGETTER(ClientIP)           (ClientIP.asOutParam ()), rc);
    1804         CHECK_ERROR_RET(remoteDisplayInfo, COMGETTER(ClientVersion)      (&ClientVersion), rc);
    1805         CHECK_ERROR_RET(remoteDisplayInfo, COMGETTER(EncryptionStyle)    (&EncryptionStyle), rc);
     1795        CHECK_ERROR_RET(remoteDisplayInfo, COMGETTER(Active)(&Active), rc);
     1796        CHECK_ERROR_RET(remoteDisplayInfo, COMGETTER(NumberOfClients)(&NumberOfClients), rc);
     1797        CHECK_ERROR_RET(remoteDisplayInfo, COMGETTER(BeginTime)(&BeginTime), rc);
     1798        CHECK_ERROR_RET(remoteDisplayInfo, COMGETTER(EndTime)(&EndTime), rc);
     1799        CHECK_ERROR_RET(remoteDisplayInfo, COMGETTER(BytesSent)(&BytesSent), rc);
     1800        CHECK_ERROR_RET(remoteDisplayInfo, COMGETTER(BytesSentTotal)(&BytesSentTotal), rc);
     1801        CHECK_ERROR_RET(remoteDisplayInfo, COMGETTER(BytesReceived)(&BytesReceived), rc);
     1802        CHECK_ERROR_RET(remoteDisplayInfo, COMGETTER(BytesReceivedTotal)(&BytesReceivedTotal), rc);
     1803        CHECK_ERROR_RET(remoteDisplayInfo, COMGETTER(User)(User.asOutParam()), rc);
     1804        CHECK_ERROR_RET(remoteDisplayInfo, COMGETTER(Domain)(Domain.asOutParam()), rc);
     1805        CHECK_ERROR_RET(remoteDisplayInfo, COMGETTER(ClientName)(ClientName.asOutParam()), rc);
     1806        CHECK_ERROR_RET(remoteDisplayInfo, COMGETTER(ClientIP)(ClientIP.asOutParam()), rc);
     1807        CHECK_ERROR_RET(remoteDisplayInfo, COMGETTER(ClientVersion)(&ClientVersion), rc);
     1808        CHECK_ERROR_RET(remoteDisplayInfo, COMGETTER(EncryptionStyle)(&EncryptionStyle), rc);
    18061809
    18071810        if (details == VMINFO_MACHINEREADABLE)
    … …  
    18211824            if (Active)
    18221825            {
    1823                 makeTimeStr (timestr, sizeof (timestr), BeginTime);
     1826                makeTimeStr(timestr, sizeof(timestr), BeginTime);
    18241827                if (details == VMINFO_MACHINEREADABLE)
    18251828                    RTPrintf("VRDPStartTime=\"%s\"\n", timestr);
    … …  
    18291832            else
    18301833            {
    1831                 makeTimeStr (timestr, sizeof (timestr), BeginTime);
     1834                makeTimeStr(timestr, sizeof(timestr), BeginTime);
    18321835                if (details == VMINFO_MACHINEREADABLE)
    18331836                    RTPrintf("VRDPLastStartTime=\"%s\"\n", timestr);
    18341837                else
    18351838                    RTPrintf("Last started:       %s\n", timestr);
    1836                 makeTimeStr (timestr, sizeof (timestr), EndTime);
     1839                makeTimeStr(timestr, sizeof(timestr), EndTime);
    18371840                if (details == VMINFO_MACHINEREADABLE)
    18381841                    RTPrintf("VRDPLastEndTime=\"%s\"\n", timestr);
    … …  
    19741977     */
    19751978    ComPtr<ISnapshot> snapshot;
    1976     rc = machine->GetSnapshot(Bstr(), snapshot.asOutParam());
     1979    rc = machine->GetSnapshot(Bstr().raw(), snapshot.asOutParam());
    19771980    if (SUCCEEDED(rc) && snapshot)
    19781981    {
    … …  
    20702073    if (!Guid(VMNameOrUuid).isEmpty())
    20712074    {
    2072         CHECK_ERROR(a->virtualBox, GetMachine(uuid, machine.asOutParam()));
    2073     }
    2074     else
    2075     {
    2076         CHECK_ERROR(a->virtualBox, FindMachine(Bstr(VMNameOrUuid), machine.asOutParam()));
     2075        CHECK_ERROR(a->virtualBox, GetMachine(uuid.raw(),
     2076                                              machine.asOutParam()));
     2077    }
     2078    else
     2079    {
     2080        CHECK_ERROR(a->virtualBox, FindMachine(Bstr(VMNameOrUuid).raw(),
     2081                                               machine.asOutParam()));
    20772082        if (SUCCEEDED(rc))
    20782083            machine->COMGETTER(Id)(uuid.asOutParam());

  • trunk/src/VBox/Frontends/VBoxManage/VBoxManageMetrics.cpp

    r32701 r32718  
    111111        {
    112112            ComPtr <IMachine> machine;
    113             rc = aVirtualBox->FindMachine(Bstr(argv[0]), machine.asOutParam());
     113            rc = aVirtualBox->FindMachine(Bstr(argv[0]).raw(),
     114                                          machine.asOutParam());
    114115            if (SUCCEEDED (rc))
    115116            {

  • trunk/src/VBox/Frontends/VBoxManage/VBoxManageMisc.cpp

    r32701 r32718  
    7070     * and the client's interpretation of relative paths. Remove after the API
    7171     * has been redesigned. */
    72     rc = a->virtualBox->OpenMachine(Bstr(a->argv[0]), machine.asOutParam());
     72    rc = a->virtualBox->OpenMachine(Bstr(a->argv[0]).raw(),
     73                                    machine.asOutParam());
    7374    if (rc == VBOX_E_FILE_ERROR)
    7475    {
    … …  
    8081            return 1;
    8182        }
    82         CHECK_ERROR(a->virtualBox, OpenMachine(Bstr(szVMFileAbs), machine.asOutParam()));
     83        CHECK_ERROR(a->virtualBox, OpenMachine(Bstr(szVMFileAbs).raw(),
     84                                               machine.asOutParam()));
    8385    }
    8486    else if (FAILED(rc))
    85         CHECK_ERROR(a->virtualBox, OpenMachine(Bstr(a->argv[0]), machine.asOutParam()));
     87        CHECK_ERROR(a->virtualBox, OpenMachine(Bstr(a->argv[0]).raw(),
     88                                               machine.asOutParam()));
    8689    if (SUCCEEDED(rc))
    8790    {
    … …  
    148151    ComPtr<IMachine> machine;
    149152    /* assume it's a UUID */
    150     rc = a->virtualBox->GetMachine(Guid(VMName).toUtf16(), machine.asOutParam());
     153    rc = a->virtualBox->GetMachine(Bstr(VMName).raw(), machine.asOutParam());
    151154    if (FAILED(rc) || !machine)
    152155    {
    153156        /* must be a name */
    154         CHECK_ERROR(a->virtualBox, FindMachine(Bstr(VMName), machine.asOutParam()));
     157        CHECK_ERROR(a->virtualBox, FindMachine(Bstr(VMName).raw(),
     158                                               machine.asOutParam()));
    155159    }
    156160    if (machine)
    … …  
    230234
    231235    /* check for required options */
    232     if (name)
     236    if (name.isEmpty())
    233237        return errorSyntax(USAGE_CREATEVM, "Parameter --name is required");
    234238
    … …  
    238242
    239243        CHECK_ERROR_BREAK(a->virtualBox,
    240                           CreateMachine(name,
    241                                         osTypeId,
    242                                         baseFolder,
    243                                         Guid(id).toUtf16(),
     244                          CreateMachine(name.raw(),
     245                                        osTypeId.raw(),
     246                                        baseFolder.raw(),
     247                                        Guid(id).toUtf16().raw(),
    244248                                        FALSE,
    245249                                        machine.asOutParam()));
    … …  
    347351    ComPtr<IMachine> machine;
    348352    /* assume it's a UUID */
    349     rc = a->virtualBox->GetMachine(Guid(VMName).toUtf16(), machine.asOutParam());
     353    rc = a->virtualBox->GetMachine(Bstr(VMName).raw(), machine.asOutParam());
    350354    if (FAILED(rc) || !machine)
    351355    {
    352356        /* must be a name */
    353         CHECK_ERROR(a->virtualBox, FindMachine(Bstr(VMName), machine.asOutParam()));
     357        CHECK_ERROR(a->virtualBox, FindMachine(Bstr(VMName).raw(),
     358                                               machine.asOutParam()));
    354359    }
    355360    if (machine)
    … …  
    368373#endif
    369374        ComPtr<IProgress> progress;
    370         CHECK_ERROR_RET(machine, LaunchVMProcess(a->session, sessionType, env, progress.asOutParam()), rc);
     375        CHECK_ERROR_RET(machine, LaunchVMProcess(a->session, sessionType.raw(),
     376                                                 env.raw(), progress.asOutParam()), rc);
    371377        RTPrintf("Waiting for the VM to power on...\n");
    372378        CHECK_ERROR_RET(progress, WaitForCompletion(-1), 1);
    … …  
    406412    ComPtr<IMachine> machine;
    407413    /* assume it's a UUID */
    408     rc = a->virtualBox->GetMachine(Bstr(a->argv[0]), machine.asOutParam());
     414    rc = a->virtualBox->GetMachine(Bstr(a->argv[0]).raw(),
     415                                   machine.asOutParam());
    409416    if (FAILED(rc) || !machine)
    410417    {
    411418        /* must be a name */
    412         CHECK_ERROR(a->virtualBox, FindMachine(Bstr(a->argv[0]), machine.asOutParam()));
     419        CHECK_ERROR(a->virtualBox, FindMachine(Bstr(a->argv[0]).raw(),
     420                                               machine.asOutParam()));
    413421    }
    414422    if (machine)
    … …  
    440448    ComPtr<IMachine> machine;
    441449    /* assume it's a UUID */
    442     rc = a->virtualBox->GetMachine(Bstr(a->argv[0]), machine.asOutParam());
     450    rc = a->virtualBox->GetMachine(Bstr(a->argv[0]).raw(),
     451                                   machine.asOutParam());
    443452    if (FAILED(rc) || !machine)
    444453    {
    445454        /* must be a name */
    446         CHECK_ERROR(a->virtualBox, FindMachine(Bstr(a->argv[0]), machine.asOutParam()));
     455        CHECK_ERROR(a->virtualBox, FindMachine(Bstr(a->argv[0]).raw(),
     456                                               machine.asOutParam()));
    447457    }
    448458    if (machine)
    … …  
    456466                ComPtr<IConsole> console;
    457467                CHECK_ERROR_BREAK(a->session, COMGETTER(Console)(console.asOutParam()));
    458                 CHECK_ERROR_BREAK(console, AdoptSavedState(Bstr(a->argv[1])));
     468                CHECK_ERROR_BREAK(console, AdoptSavedState(Bstr(a->argv[1]).raw()));
    459469            } while (0);
    460470            CHECK_ERROR_BREAK(a->session, UnlockMachine());
    … …  
    487497                Bstr bstrKey(aKeys[i]);
    488498                Bstr bstrValue;
    489                 CHECK_ERROR(a->virtualBox, GetExtraData(bstrKey, bstrValue.asOutParam()));
     499                CHECK_ERROR(a->virtualBox, GetExtraData(bstrKey.raw(),
     500                                                        bstrValue.asOutParam()));
    490501
    491502                RTPrintf("Key: %lS, Value: %lS\n", bstrKey.raw(), bstrValue.raw());
    … …  
    495506        {
    496507            Bstr value;
    497             CHECK_ERROR(a->virtualBox, GetExtraData(Bstr(a->argv[1]), value.asOutParam()));
     508            CHECK_ERROR(a->virtualBox, GetExtraData(Bstr(a->argv[1]).raw(),
     509                                                    value.asOutParam()));
    498510            if (!value.isEmpty())
    499511                RTPrintf("Value: %lS\n", value.raw());
    … …  
    506518        ComPtr<IMachine> machine;
    507519        /* assume it's a UUID */
    508         rc = a->virtualBox->GetMachine(Bstr(a->argv[0]), machine.asOutParam());
     520        rc = a->virtualBox->GetMachine(Bstr(a->argv[0]).raw(),
     521                                       machine.asOutParam());
    509522        if (FAILED(rc) || !machine)
    510523        {
    511524            /* must be a name */
    512             CHECK_ERROR(a->virtualBox, FindMachine(Bstr(a->argv[0]), machine.asOutParam()));
     525            CHECK_ERROR(a->virtualBox, FindMachine(Bstr(a->argv[0]).raw(),
     526                                                   machine.asOutParam()));
    513527        }
    514528        if (machine)
    … …  
    526540                    Bstr bstrKey(aKeys[i]);
    527541                    Bstr bstrValue;
    528                     CHECK_ERROR(machine, GetExtraData(bstrKey, bstrValue.asOutParam()));
     542                    CHECK_ERROR(machine, GetExtraData(bstrKey.raw(),
     543                                                      bstrValue.asOutParam()));
    529544
    530545                    RTPrintf("Key: %lS, Value: %lS\n", bstrKey.raw(), bstrValue.raw());
    … …  
    534549            {
    535550                Bstr value;
    536                 CHECK_ERROR(machine, GetExtraData(Bstr(a->argv[1]), value.asOutParam()));
     551                CHECK_ERROR(machine, GetExtraData(Bstr(a->argv[1]).raw(),
     552                                                  value.asOutParam()));
    537553                if (!value.isEmpty())
    538554                    RTPrintf("Value: %lS\n", value.raw());
    … …  
    555571    if (!strcmp(a->argv[0], "global"))
    556572    {
     573        /** @todo passing NULL is deprecated */
    557574        if (a->argc < 3)
    558             CHECK_ERROR(a->virtualBox, SetExtraData(Bstr(a->argv[1]), NULL));
     575            CHECK_ERROR(a->virtualBox, SetExtraData(Bstr(a->argv[1]).raw(),
     576                                                    NULL));
    559577        else if (a->argc == 3)
    560             CHECK_ERROR(a->virtualBox, SetExtraData(Bstr(a->argv[1]), Bstr(a->argv[2])));
     578            CHECK_ERROR(a->virtualBox, SetExtraData(Bstr(a->argv[1]).raw(),
     579                                                    Bstr(a->argv[2]).raw()));
    561580        else
    562581            return errorSyntax(USAGE_SETEXTRADATA, "Too many parameters");
    … …  
    566585        ComPtr<IMachine> machine;
    567586        /* assume it's a UUID */
    568         rc = a->virtualBox->GetMachine(Bstr(a->argv[0]), machine.asOutParam());
     587        rc = a->virtualBox->GetMachine(Bstr(a->argv[0]).raw(),
     588                                       machine.asOutParam());
    569589        if (FAILED(rc) || !machine)
    570590        {
    571591            /* must be a name */
    572             CHECK_ERROR(a->virtualBox, FindMachine(Bstr(a->argv[0]), machine.asOutParam()));
     592            CHECK_ERROR(a->virtualBox, FindMachine(Bstr(a->argv[0]).raw(),
     593                                       machine.asOutParam()));
    573594        }
    574595        if (machine)
    575596        {
     597            /** @todo passing NULL is deprecated */
    576598            if (a->argc < 3)
    577                 CHECK_ERROR(machine, SetExtraData(Bstr(a->argv[1]), NULL));
     599                CHECK_ERROR(machine, SetExtraData(Bstr(a->argv[1]).raw(),
     600                                                  NULL));
    578601            else if (a->argc == 3)
    579                 CHECK_ERROR(machine, SetExtraData(Bstr(a->argv[1]), Bstr(a->argv[2])));
     602                CHECK_ERROR(machine, SetExtraData(Bstr(a->argv[1]).raw(),
     603                                                  Bstr(a->argv[2]).raw()));
    580604            else
    581605                return errorSyntax(USAGE_SETEXTRADATA, "Too many parameters");
    … …  
    602626            CHECK_ERROR(systemProperties, COMSETTER(DefaultHardDiskFolder)(NULL));
    603627        else
    604             CHECK_ERROR(systemProperties, COMSETTER(DefaultHardDiskFolder)(Bstr(a->argv[1])));
     628            CHECK_ERROR(systemProperties, COMSETTER(DefaultHardDiskFolder)(Bstr(a->argv[1]).raw()));
    605629    }
    606630    else if (!strcmp(a->argv[0], "machinefolder"))
    … …  
    610634            CHECK_ERROR(systemProperties, COMSETTER(DefaultMachineFolder)(NULL));
    611635        else
    612             CHECK_ERROR(systemProperties, COMSETTER(DefaultMachineFolder)(Bstr(a->argv[1])));
     636            CHECK_ERROR(systemProperties, COMSETTER(DefaultMachineFolder)(Bstr(a->argv[1]).raw()));
    613637    }
    614638    else if (!strcmp(a->argv[0], "vrdpauthlibrary"))
    … …  
    618642            CHECK_ERROR(systemProperties, COMSETTER(RemoteDisplayAuthLibrary)(NULL));
    619643        else
    620             CHECK_ERROR(systemProperties, COMSETTER(RemoteDisplayAuthLibrary)(Bstr(a->argv[1])));
     644            CHECK_ERROR(systemProperties, COMSETTER(RemoteDisplayAuthLibrary)(Bstr(a->argv[1]).raw()));
    621645    }
    622646    else if (!strcmp(a->argv[0], "websrvauthlibrary"))
    … …  
    626650            CHECK_ERROR(systemProperties, COMSETTER(WebServiceAuthLibrary)(NULL));
    627651        else
    628             CHECK_ERROR(systemProperties, COMSETTER(WebServiceAuthLibrary)(Bstr(a->argv[1])));
     652            CHECK_ERROR(systemProperties, COMSETTER(WebServiceAuthLibrary)(Bstr(a->argv[1]).raw()));
    629653    }
    630654    else if (!strcmp(a->argv[0], "loghistorycount"))
    … …  
    653677    ComPtr<IMachine> machine;
    654678    /* assume it's a UUID */
    655     rc = a->virtualBox->GetMachine(Bstr(a->argv[1]), machine.asOutParam());
     679    rc = a->virtualBox->GetMachine(Bstr(a->argv[1]).raw(),
     680                                   machine.asOutParam());
    656681    if (FAILED(rc) || !machine)
    657682    {
    658683        /* must be a name */
    659         CHECK_ERROR(a->virtualBox, FindMachine(Bstr(a->argv[1]), machine.asOutParam()));
     684        CHECK_ERROR(a->virtualBox, FindMachine(Bstr(a->argv[1]).raw(),
     685                                               machine.asOutParam()));
    660686    }
    661687    if (!machine)
    … …  
    731757            CHECK_ERROR_RET(a->session, COMGETTER(Console)(console.asOutParam()), 1);
    732758
    733             CHECK_ERROR(console, CreateSharedFolder(Bstr(name), Bstr(hostpath),
     759            CHECK_ERROR(console, CreateSharedFolder(Bstr(name).raw(),
     760                                                    Bstr(hostpath).raw(),
    734761                                                    fWritable, fAutoMount));
    735762            if (console)
    … …  
    745772            a->session->COMGETTER(Machine)(machine.asOutParam());
    746773
    747             CHECK_ERROR(machine, CreateSharedFolder(Bstr(name), Bstr(hostpath),
     774            CHECK_ERROR(machine, CreateSharedFolder(Bstr(name).raw(),
     775                                                    Bstr(hostpath).raw(),
    748776                                                    fWritable, fAutoMount));
    749777            if (SUCCEEDED(rc))
    … …  
    796824            CHECK_ERROR_RET(a->session, COMGETTER(Console)(console.asOutParam()), 1);
    797825
    798             CHECK_ERROR(console, RemoveSharedFolder(Bstr(name)));
     826            CHECK_ERROR(console, RemoveSharedFolder(Bstr(name).raw()));
    799827
    800828            if (console)
    … …  
    809837            a->session->COMGETTER(Machine)(machine.asOutParam());
    810838
    811             CHECK_ERROR(machine, RemoveSharedFolder(Bstr(name)));
     839            CHECK_ERROR(machine, RemoveSharedFolder(Bstr(name).raw()));
    812840
    813841            /* commit and close the session */
    … …  
    834862    Bstr uuid(a->argv[0]);
    835863    if (!Guid(a->argv[0]).isEmpty())
    836         CHECK_ERROR(a->virtualBox, GetMachine(uuid, machine.asOutParam()));
     864        CHECK_ERROR(a->virtualBox, GetMachine(uuid.raw(),
     865                                              machine.asOutParam()));
    837866    else
    838867    {
    839         CHECK_ERROR(a->virtualBox, FindMachine(Bstr(a->argv[0]), machine.asOutParam()));
     868        CHECK_ERROR(a->virtualBox, FindMachine(Bstr(a->argv[0]).raw(),
     869                                               machine.asOutParam()));
    840870        if (SUCCEEDED(rc))
    841871            machine->COMGETTER(Id)(uuid.asOutParam());
    … …  
    888918            {
    889919                if (fReset)
    890                     CHECK_ERROR(debugger, ResetStats(Bstr(pszPattern)));
     920                    CHECK_ERROR(debugger, ResetStats(Bstr(pszPattern).raw()));
    891921                else
    892922                {
    893923                    Bstr stats;
    894                     CHECK_ERROR(debugger, GetStats(Bstr(pszPattern), fWithDescriptions, stats.asOutParam()));
     924                    CHECK_ERROR(debugger, GetStats(Bstr(pszPattern).raw(),
     925                                                   fWithDescriptions,
     926                                                   stats.asOutParam()));
    895927                    if (SUCCEEDED(rc))
    896928                    {

  • trunk/src/VBox/Frontends/VBoxManage/VBoxManageModifyVM.cpp

    r32701 r32718  
    55
    66/*
    7  * Copyright (C) 2006-2009 Oracle Corporation
     7 * Copyright (C) 2006-2010 Oracle Corporation
    88 *
    99 * This file is part of VirtualBox Open Source Edition (OSE), as
    … …  
    308308    if (!Guid(machineuuid).isEmpty())
    309309    {
    310         CHECK_ERROR_RET(a->virtualBox, GetMachine(machineuuid, machine.asOutParam()), 1);
     310        CHECK_ERROR_RET(a->virtualBox, GetMachine(machineuuid.raw(),
     311                                                  machine.asOutParam()), 1);
    311312    }
    312313    else
    313314    {
    314         CHECK_ERROR_RET(a->virtualBox, FindMachine(Bstr(a->argv[0]), machine.asOutParam()), 1);
     315        CHECK_ERROR_RET(a->virtualBox, FindMachine(Bstr(a->argv[0]).raw(),
     316                                                   machine.asOutParam()), 1);
    315317        machine->COMGETTER(Id)(machineuuid.asOutParam());
    316318    }
    … …  
    333335            case MODIFYVM_NAME:
    334336            {
    335                 CHECK_ERROR(machine, COMSETTER(Name)(Bstr(ValueUnion.psz)));
     337                CHECK_ERROR(machine, COMSETTER(Name)(Bstr(ValueUnion.psz).raw()));
    336338                break;
    337339            }
    … …  
    339341            {
    340342                ComPtr<IGuestOSType> guestOSType;
    341                 CHECK_ERROR(a->virtualBox, GetGuestOSType(Bstr(ValueUnion.psz), guestOSType.asOutParam()));
     343                CHECK_ERROR(a->virtualBox, GetGuestOSType(Bstr(ValueUnion.psz).raw(),
     344                                                          guestOSType.asOutParam()));
    342345                if (SUCCEEDED(rc) && guestOSType)
    343346                {
    344                     CHECK_ERROR(machine, COMSETTER(OSTypeId)(Bstr(ValueUnion.psz)));
     347                    CHECK_ERROR(machine, COMSETTER(OSTypeId)(Bstr(ValueUnion.psz).raw()));
    345348                }
    346349                else
    … …  
    554557            case MODIFYVM_BIOSLOGOIMAGEPATH:
    555558            {
    556                 CHECK_ERROR(biosSettings, COMSETTER(LogoImagePath)(Bstr(ValueUnion.psz)));
     559                CHECK_ERROR(biosSettings, COMSETTER(LogoImagePath)(Bstr(ValueUnion.psz).raw()));
    557560                break;
    558561            }
    … …  
    651654                if (!strcmp(ValueUnion.psz, "none"))
    652655                {
    653                     machine->DetachDevice(bstrController, u1, u2);
     656                    machine->DetachDevice(bstrController.raw(), u1, u2);
    654657                }
    655658                else
    656659                {
    657660                    ComPtr<IMedium> hardDisk;
    658                     rc = a->virtualBox->FindMedium(Bstr(ValueUnion.psz), DeviceType_HardDisk, hardDisk.asOutParam());
     661                    rc = a->virtualBox->FindMedium(Bstr(ValueUnion.psz).raw(),
     662                                                   DeviceType_HardDisk,
     663                                                   hardDisk.asOutParam());
    659664                    if (FAILED(rc))
    660665                    {
    661666                        /* open the new hard disk object */
    662667                        CHECK_ERROR(a->virtualBox,
    663                                     OpenMedium(Bstr(ValueUnion.psz),
     668                                    OpenMedium(Bstr(ValueUnion.psz).raw(),
    664669                                               DeviceType_HardDisk,
    665670                                               AccessMode_ReadWrite,
    … …  
    668673                    if (hardDisk)
    669674                    {
    670                         CHECK_ERROR(machine, AttachDevice(bstrController, u1, u2, DeviceType_HardDisk, hardDisk));
     675                        CHECK_ERROR(machine, AttachDevice(bstrController.raw(),
     676                                                          u1, u2,
     677                                                          DeviceType_HardDisk,
     678                                                          hardDisk));
    671679                    }
    672680                    else
    … …  
    679687            {
    680688                ComPtr<IStorageController> storageController;
    681                 CHECK_ERROR(machine, GetStorageControllerByName(Bstr("IDE Controller"),
     689                CHECK_ERROR(machine, GetStorageControllerByName(Bstr("IDE Controller").raw(),
    682690                                                                 storageController.asOutParam()));
    683691
    … …  
    705713            {
    706714                ComPtr<IStorageController> SataCtl;
    707                 CHECK_ERROR(machine, GetStorageControllerByName(Bstr("SATA"), SataCtl.asOutParam()));
     715                CHECK_ERROR(machine, GetStorageControllerByName(Bstr("SATA").raw(),
     716                                                                SataCtl.asOutParam()));
    708717
    709718                if (SUCCEEDED(rc))
    … …  
    715724            {
    716725                ComPtr<IStorageController> SataCtl;
    717                 CHECK_ERROR(machine, GetStorageControllerByName(Bstr("SATA"), SataCtl.asOutParam()));
     726                CHECK_ERROR(machine, GetStorageControllerByName(Bstr("SATA").raw(),
     727                                                                SataCtl.asOutParam()));
    718728
    719729                if (SUCCEEDED(rc) && ValueUnion.u32 > 0)
    … …  
    727737                {
    728738                    ComPtr<IStorageController> ctl;
    729                     CHECK_ERROR(machine, AddStorageController(Bstr("SATA"), StorageBus_SATA, ctl.asOutParam()));
     739                    CHECK_ERROR(machine, AddStorageController(Bstr("SATA").raw(),
     740                                                              StorageBus_SATA,
     741                                                              ctl.asOutParam()));
    730742                    CHECK_ERROR(ctl, COMSETTER(ControllerType)(StorageControllerType_IntelAhci));
    731743                }
    732744                else if (!strcmp(ValueUnion.psz, "off") || !strcmp(ValueUnion.psz, "disable"))
    733                     CHECK_ERROR(machine, RemoveStorageController(Bstr("SATA")));
     745                    CHECK_ERROR(machine, RemoveStorageController(Bstr("SATA").raw()));
    734746                else
    735747                    return errorArgument("Invalid --usb argument '%s'", ValueUnion.psz);
    … …  
    741753                if (!strcmp(ValueUnion.psz, "none"))
    742754                {
    743                     rc = machine->DetachDevice(Bstr("LsiLogic"), GetOptState.uIndex, 0);
     755                    rc = machine->DetachDevice(Bstr("LsiLogic").raw(),
     756                                               GetOptState.uIndex, 0);
    744757                    if (FAILED(rc))
    745                         CHECK_ERROR(machine, DetachDevice(Bstr("BusLogic"), GetOptState.uIndex, 0));
     758                        CHECK_ERROR(machine, DetachDevice(Bstr("BusLogic").raw(),
     759                                                          GetOptState.uIndex, 0));
    746760                }
    747761                else
    … …  
    749763                    /* first guess is that it's a UUID */
    750764                    ComPtr<IMedium> hardDisk;
    751                     rc = a->virtualBox->FindMedium(Bstr(ValueUnion.psz), DeviceType_HardDisk, hardDisk.asOutParam());
     765                    rc = a->virtualBox->FindMedium(Bstr(ValueUnion.psz).raw(),
     766                                                   DeviceType_HardDisk,
     767                                                   hardDisk.asOutParam());
    752768                    /* not successful? Then it must be a filename */
    753769                    if (FAILED(rc))
    … …  
    755771                        /* open the new hard disk object */
    756772                        CHECK_ERROR(a->virtualBox,
    757                                     OpenMedium(Bstr(ValueUnion.psz),
     773                                    OpenMedium(Bstr(ValueUnion.psz).raw(),
    758774                                               DeviceType_HardDisk,
    759775                                               AccessMode_ReadWrite,
    … …  
    762778                    if (hardDisk)
    763779                    {
    764                         rc = machine->AttachDevice(Bstr("LsiLogic"), GetOptState.uIndex, 0, DeviceType_HardDisk, hardDisk);
     780                        rc = machine->AttachDevice(Bstr("LsiLogic").raw(),
     781                                                   GetOptState.uIndex, 0,
     782                                                   DeviceType_HardDisk,
     783                                                   hardDisk);
    765784                        if (FAILED(rc))
    766785                            CHECK_ERROR(machine,
    767                                          AttachDevice(Bstr("BusLogic"),
    768                                                       GetOptState.uIndex, 0,
    769                                                       DeviceType_HardDisk, hardDisk));
     786                                        AttachDevice(Bstr("BusLogic").raw(),
     787                                                     GetOptState.uIndex, 0,
     788                                                     DeviceType_HardDisk,
     789                                                     hardDisk));
    770790                    }
    771791                    else
    … …  
    781801                if (!RTStrICmp(ValueUnion.psz, "LsiLogic"))
    782802                {
    783                     rc = machine->RemoveStorageController(Bstr("BusLogic"));
     803                    rc = machine->RemoveStorageController(Bstr("BusLogic").raw());
    784804                    if (FAILED(rc))
    785                         CHECK_ERROR(machine, RemoveStorageController(Bstr("LsiLogic")));
     805                        CHECK_ERROR(machine, RemoveStorageController(Bstr("LsiLogic").raw()));
    786806
    787807                    CHECK_ERROR(machine,
    788                                  AddStorageController(Bstr("LsiLogic"),
     808                                 AddStorageController(Bstr("LsiLogic").raw(),
    789809                                                      StorageBus_SCSI,
    790810                                                      ctl.asOutParam()));
    … …  
    795815                else if (!RTStrICmp(ValueUnion.psz, "BusLogic"))
    796816                {
    797                     rc = machine->RemoveStorageController(Bstr("LsiLogic"));
     817                    rc = machine->RemoveStorageController(Bstr("LsiLogic").raw());
    798818                    if (FAILED(rc))
    799                         CHECK_ERROR(machine, RemoveStorageController(Bstr("BusLogic")));
     819                        CHECK_ERROR(machine, RemoveStorageController(Bstr("BusLogic").raw()));
    800820
    801821                    CHECK_ERROR(machine,
    802                                  AddStorageController(Bstr("BusLogic"),
     822                                 AddStorageController(Bstr("BusLogic").raw(),
    803823                                                      StorageBus_SCSI,
    804824                                                      ctl.asOutParam()));
    … …  
    818838                    ComPtr<IStorageController> ctl;
    819839
    820                     CHECK_ERROR(machine, AddStorageController(Bstr("BusLogic"), StorageBus_SCSI, ctl.asOutParam()));
     840                    CHECK_ERROR(machine, AddStorageController(Bstr("BusLogic").raw(),
     841                                                              StorageBus_SCSI,
     842                                                              ctl.asOutParam()));
    821843                    if (SUCCEEDED(rc))
    822844                        CHECK_ERROR(ctl, COMSETTER(ControllerType)(StorageControllerType_BusLogic));
    … …  
    824846                else if (!strcmp(ValueUnion.psz, "off") || !strcmp(ValueUnion.psz, "disable"))
    825847                {
    826                     rc = machine->RemoveStorageController(Bstr("BusLogic"));
     848                    rc = machine->RemoveStorageController(Bstr("BusLogic").raw());
    827849                    if (FAILED(rc))
    828                         CHECK_ERROR(machine, RemoveStorageController(Bstr("LsiLogic")));
     850                        CHECK_ERROR(machine, RemoveStorageController(Bstr("LsiLogic").raw()));
    829851                }
    830852                break;
    … …  
    833855            case MODIFYVM_DVDPASSTHROUGH: // deprecated
    834856            {
    835                 CHECK_ERROR(machine, PassthroughDevice(Bstr("IDE Controller"), 1, 0, !strcmp(ValueUnion.psz, "on")));
     857                CHECK_ERROR(machine, PassthroughDevice(Bstr("IDE Controller").raw(),
     858                                                       1, 0,
     859                                                       !strcmp(ValueUnion.psz, "on")));
    836860                break;
    837861            }
    … …  
    852876                    ComPtr<IHost> host;
    853877                    CHECK_ERROR(a->virtualBox, COMGETTER(Host)(host.asOutParam()));
    854                     rc = host->FindHostDVDDrive(Bstr(ValueUnion.psz + 5), dvdMedium.asOutParam());
     878                    rc = host->FindHostDVDDrive(Bstr(ValueUnion.psz + 5).raw(),
     879                                                dvdMedium.asOutParam());
    855880                    if (!dvdMedium)
    856881                    {
    … …  
    863888                            break;
    864889                        }
    865                         rc = host->FindHostDVDDrive(Bstr(szPathReal), dvdMedium.asOutParam());
     890                        rc = host->FindHostDVDDrive(Bstr(szPathReal).raw(),
     891                                                    dvdMedium.asOutParam());
    866892                        if (!dvdMedium)
    867893                        {
    … …  
    875901                {
    876902                    /* first assume it's a UUID */
    877                     rc = a->virtualBox->FindMedium(Bstr(ValueUnion.psz), DeviceType_DVD, dvdMedium.asOutParam());
     903                    rc = a->virtualBox->FindMedium(Bstr(ValueUnion.psz).raw(),
     904                                                   DeviceType_DVD,
     905                                                   dvdMedium.asOutParam());
    878906                    if (FAILED(rc) || !dvdMedium)
    879907                    {
    … …  
    881909                        Bstr emptyUUID;
    882910                        CHECK_ERROR(a->virtualBox,
    883                                     OpenMedium(Bstr(ValueUnion.psz),
     911                                    OpenMedium(Bstr(ValueUnion.psz).raw(),
    884912                                               DeviceType_DVD,
    885913                                               AccessMode_ReadWrite,
    … …  
    893921                }
    894922
    895                 /** @todo generalize this, allow arbitrary number of DVD drives
    896                  * and as a consequence multiple attachments and different
    897                  * storage controllers. */
    898923                if (dvdMedium)
    899924                    dvdMedium->COMGETTER(Id)(uuid.asOutParam());
    900                 CHECK_ERROR(machine, MountMedium(Bstr("IDE Controller"), 1, 0, uuid, FALSE /* aForce */));
     925                CHECK_ERROR(machine, MountMedium(Bstr("IDE Controller").raw(),
     926                                                 1, 0, uuid.raw(),
     927                                                 FALSE /* aForce */));
    901928                break;
    902929            }
    … …  
    907934                ComPtr<IMedium> floppyMedium;
    908935                ComPtr<IMediumAttachment> floppyAttachment;
    909                 machine->GetMediumAttachment(Bstr("Floppy Controller"), 0, 0, floppyAttachment.asOutParam());
     936                machine->GetMediumAttachment(Bstr("Floppy Controller").raw(),
     937                                             0, 0, floppyAttachment.asOutParam());
    910938
    911939                /* disable? */
    … …  
    914942                    /* disable the controller */
    915943                    if (floppyAttachment)
    916                         CHECK_ERROR(machine, DetachDevice(Bstr("Floppy Controller"), 0, 0));
     944                        CHECK_ERROR(machine, DetachDevice(Bstr("Floppy Controller").raw(),
     945                                                          0, 0));
    917946                }
    918947                else
    … …  
    920949                    /* enable the controller */
    921950                    if (!floppyAttachment)
    922                         CHECK_ERROR(machine, AttachDevice(Bstr("Floppy Controller"), 0, 0, DeviceType_Floppy, NULL));
     951                        CHECK_ERROR(machine, AttachDevice(Bstr("Floppy Controller").raw(),
     952                                                          0, 0,
     953                                                          DeviceType_Floppy, NULL));
    923954
    924955                    /* unmount? */
    … …  
    933964                        ComPtr<IHost> host;
    934965                        CHECK_ERROR(a->virtualBox, COMGETTER(Host)(host.asOutParam()));
    935                         rc = host->FindHostFloppyDrive(Bstr(ValueUnion.psz + 5), floppyMedium.asOutParam());
     966                        rc = host->FindHostFloppyDrive(Bstr(ValueUnion.psz + 5).raw(),
     967                                                       floppyMedium.asOutParam());
    936968                        if (!floppyMedium)
    937969                        {
    … …  
    944976                    {
    945977                        /* first assume it's a UUID */
    946                         rc = a->virtualBox->FindMedium(Bstr(ValueUnion.psz), DeviceType_Floppy, floppyMedium.asOutParam());
     978                        rc = a->virtualBox->FindMedium(Bstr(ValueUnion.psz).raw(),
     979                                                       DeviceType_Floppy,
     980                                                       floppyMedium.asOutParam());
    947981                        if (FAILED(rc) || !floppyMedium)
    948982                        {
    … …  
    950984                            Bstr emptyUUID;
    951985                            CHECK_ERROR(a->virtualBox,
    952                                         OpenMedium(Bstr(ValueUnion.psz),
     986                                        OpenMedium(Bstr(ValueUnion.psz).raw(),
    953987                                                   DeviceType_Floppy,
    954988                                                   AccessMode_ReadWrite,
    … …  
    962996                    }
    963997                    floppyMedium->COMGETTER(Id)(uuid.asOutParam());
    964                     CHECK_ERROR(machine, MountMedium(Bstr("Floppy Controller"), 0, 0, uuid, FALSE /* aForce */));
     998                    CHECK_ERROR(machine, MountMedium(Bstr("Floppy Controller").raw(),
     999                                                     0, 0, uuid.raw(),
     1000                                                     FALSE /* aForce */));
    9651001                }
    9661002                break;
    … …  
    9741010                ASSERT(nic);
    9751011
    976                 CHECK_ERROR(nic, COMSETTER(TraceFile)(Bstr(ValueUnion.psz)));
     1012                CHECK_ERROR(nic, COMSETTER(TraceFile)(Bstr(ValueUnion.psz).raw()));
    9771013                break;
    9781014            }
    … …  
    11411177                ASSERT(nic);
    11421178
     1179                /** @todo NULL string deprecated */
    11431180                /* remove it? */
    11441181                if (!strcmp(ValueUnion.psz, "none"))
    … …  
    11481185                else
    11491186                {
    1150                     CHECK_ERROR(nic, COMSETTER(HostInterface)(Bstr(ValueUnion.psz)));
     1187                    CHECK_ERROR(nic, COMSETTER(HostInterface)(Bstr(ValueUnion.psz).raw()));
    11511188                }
    11521189                break;
    … …  
    11601197                ASSERT(nic);
    11611198
     1199                /** @todo NULL string deprecated */
    11621200                /* remove it? */
    11631201                if (!strcmp(ValueUnion.psz, "none"))
    … …  
    11671205                else
    11681206                {
    1169                     CHECK_ERROR(nic, COMSETTER(InternalNetwork)(Bstr(ValueUnion.psz)));
     1207                    CHECK_ERROR(nic, COMSETTER(InternalNetwork)(Bstr(ValueUnion.psz).raw()));
    11701208                }
    11711209                break;
    … …  
    11801218                ASSERT(nic);
    11811219
     1220                /** @todo NULL string deprecated */
     1221                /* remove it? */
    11821222                if (!strcmp(ValueUnion.psz, "default"))
    11831223                {
    … …  
    11861226                else
    11871227                {
    1188                     CHECK_ERROR(nic, COMSETTER(VDENetwork)(Bstr(ValueUnion.psz)));
     1228                    CHECK_ERROR(nic, COMSETTER(VDENetwork)(Bstr(ValueUnion.psz).raw()));
    11891229                }
    11901230                break;
    … …  
    12051245                    psz = "";
    12061246
    1207                 CHECK_ERROR(driver, COMSETTER(Network)(Bstr(psz)));
     1247                CHECK_ERROR(driver, COMSETTER(Network)(Bstr(psz).raw()));
    12081248                break;
    12091249            }
    … …  
    12181258
    12191259                CHECK_ERROR(nic, COMGETTER(NatDriver)(driver.asOutParam()));
    1220                 CHECK_ERROR(driver, COMSETTER(HostIP)(Bstr(ValueUnion.psz)));
     1260                CHECK_ERROR(driver, COMSETTER(HostIP)(Bstr(ValueUnion.psz).raw()));
    12211261                break;
    12221262            }
    … …  
    13111351                        break;
    13121352                    }
    1313                     CHECK_ERROR(driver, AddRedirect(Bstr(strName), proto, Bstr(strHostIp),
    1314                             RTStrToUInt16(strHostPort), Bstr(strGuestIp), RTStrToUInt16(strGuestPort)));
     1353                    CHECK_ERROR(driver, AddRedirect(Bstr(strName).raw(), proto,
     1354                                        Bstr(strHostIp).raw(),
     1355                                        RTStrToUInt16(strHostPort),
     1356                                        Bstr(strGuestIp).raw(),
     1357                                        RTStrToUInt16(strGuestPort)));
    13151358                }
    13161359                else
    … …  
    13211364                    if (RT_FAILURE(vrc))
    13221365                        return errorSyntax(USAGE_MODIFYVM, "Not enough parameters");
    1323                     CHECK_ERROR(driver, RemoveRedirect(Bstr(ValueUnion.psz)));
     1366                    CHECK_ERROR(driver, RemoveRedirect(Bstr(ValueUnion.psz).raw()));
    13241367                }
    13251368                break;
    … …  
    13701413
    13711414                CHECK_ERROR(nic, COMGETTER(NatDriver)(driver.asOutParam()));
    1372                 CHECK_ERROR(driver, COMSETTER(TftpPrefix)(Bstr(ValueUnion.psz)));
     1415                CHECK_ERROR(driver, COMSETTER(TftpPrefix)(Bstr(ValueUnion.psz).raw()));
    13731416                break;
    13741417            }
    … …  
    13831426
    13841427                CHECK_ERROR(nic, COMGETTER(NatDriver)(driver.asOutParam()));
    1385                 CHECK_ERROR(driver, COMSETTER(TftpBootFile)(Bstr(ValueUnion.psz)));
     1428                CHECK_ERROR(driver, COMSETTER(TftpBootFile)(Bstr(ValueUnion.psz).raw()));
    13861429                break;
    13871430            }
    … …  
    13961439
    13971440                CHECK_ERROR(nic, COMGETTER(NatDriver)(driver.asOutParam()));
    1398                 CHECK_ERROR(driver, COMSETTER(TftpNextServer)(Bstr(ValueUnion.psz)));
     1441                CHECK_ERROR(driver, COMSETTER(TftpNextServer)(Bstr(ValueUnion.psz).raw()));
    13991442                break;
    14001443            }
    … …  
    14511494                else
    14521495                {
    1453                     CHECK_ERROR(nic, COMSETTER(MACAddress)(Bstr(ValueUnion.psz)));
     1496                    CHECK_ERROR(nic, COMSETTER(MACAddress)(Bstr(ValueUnion.psz).raw()));
    14541497                }
    14551498                break;
    … …  
    15581601                                           GetOptState.pDef->pszLong);
    15591602
    1560                     CHECK_ERROR(uart, COMSETTER(Path)(Bstr(ValueUnion.psz)));
     1603                    CHECK_ERROR(uart, COMSETTER(Path)(Bstr(ValueUnion.psz).raw()));
    15611604
    15621605                    if (!strcmp(pszMode, "server"))
    … …  
    15771620                else
    15781621                {
    1579                     CHECK_ERROR(uart, COMSETTER(Path)(Bstr(ValueUnion.psz)));
     1622                    CHECK_ERROR(uart, COMSETTER(Path)(Bstr(ValueUnion.psz).raw()));
    15801623                    CHECK_ERROR(uart, COMSETTER(HostMode)(PortMode_HostDevice));
    15811624                }
    … …  
    17651808
    17661809                if (!strcmp(ValueUnion.psz, "default"))
    1767                     CHECK_ERROR(vrdpServer, COMSETTER(Ports)(Bstr("0")));
    1768                 else
    1769                     CHECK_ERROR(vrdpServer, COMSETTER(Ports)(Bstr(ValueUnion.psz)));
     1810                    CHECK_ERROR(vrdpServer, COMSETTER(Ports)(Bstr("0").raw()));
     1811                else
     1812                    CHECK_ERROR(vrdpServer, COMSETTER(Ports)(Bstr(ValueUnion.psz).raw()));
    17701813                break;
    17711814            }
    … …  
    17771820                ASSERT(vrdpServer);
    17781821
    1779                 CHECK_ERROR(vrdpServer, COMSETTER(NetAddress)(Bstr(ValueUnion.psz)));
     1822                CHECK_ERROR(vrdpServer, COMSETTER(NetAddress)(Bstr(ValueUnion.psz).raw()));
    17801823                break;
    17811824            }
    … …  
    18811924                    CHECK_ERROR(machine, COMSETTER(SnapshotFolder)(NULL));
    18821925                else
    1883                     CHECK_ERROR(machine, COMSETTER(SnapshotFolder)(Bstr(ValueUnion.psz)));
     1926                    CHECK_ERROR(machine, COMSETTER(SnapshotFolder)(Bstr(ValueUnion.psz).raw()));
    18841927                break;
    18851928            }
    … …  
    18991942            case MODIFYVM_TELEPORTER_ADDRESS:
    19001943            {
    1901                 CHECK_ERROR(machine, COMSETTER(TeleporterAddress)(Bstr(ValueUnion.psz)));
     1944                CHECK_ERROR(machine, COMSETTER(TeleporterAddress)(Bstr(ValueUnion.psz).raw()));
    19021945                break;
    19031946            }
    … …  
    19051948            case MODIFYVM_TELEPORTER_PASSWORD:
    19061949            {
    1907                 CHECK_ERROR(machine, COMSETTER(TeleporterPassword)(Bstr(ValueUnion.psz)));
     1950                CHECK_ERROR(machine, COMSETTER(TeleporterPassword)(Bstr(ValueUnion.psz).raw()));
    19081951                break;
    19091952            }
    … …  
    19301973            case MODIFYVM_FAULT_TOLERANCE_ADDRESS:
    19311974            {
    1932                 CHECK_ERROR(machine, COMSETTER(FaultToleranceAddress)(Bstr(ValueUnion.psz)));
     1975                CHECK_ERROR(machine, COMSETTER(FaultToleranceAddress)(Bstr(ValueUnion.psz).raw()));
    19331976                break;
    19341977            }
    … …  
    19421985            case MODIFYVM_FAULT_TOLERANCE_PASSWORD:
    19431986            {
    1944                 CHECK_ERROR(machine, COMSETTER(FaultTolerancePassword)(Bstr(ValueUnion.psz)));
     1987                CHECK_ERROR(machine, COMSETTER(FaultTolerancePassword)(Bstr(ValueUnion.psz).raw()));
    19451988                break;
    19461989            }
    … …  
    19541997            case MODIFYVM_HARDWARE_UUID:
    19551998            {
    1956                 CHECK_ERROR(machine, COMSETTER(HardwareUUID)(Bstr(ValueUnion.psz)));
     1999                CHECK_ERROR(machine, COMSETTER(HardwareUUID)(Bstr(ValueUnion.psz).raw()));
    19572000                break;
    19582001            }

  • trunk/src/VBox/Frontends/VBoxManage/VBoxManageSnapshot.cpp

    r32701 r32718  
    55
    66/*
    7  * Copyright (C) 2006-2009 Oracle Corporation
     7 * Copyright (C) 2006-2010 Oracle Corporation
    88 *
    99 * This file is part of VirtualBox Open Source Edition (OSE), as
    … …  
    172172        // get root snapshot
    173173        ComPtr<ISnapshot> pSnapshot;
    174         CHECK_ERROR_BREAK(pMachine, GetSnapshot(Bstr(""), pSnapshot.asOutParam()));
     174        CHECK_ERROR_BREAK(pMachine, GetSnapshot(Bstr("").raw(), pSnapshot.asOutParam()));
    175175
    176176        // get current snapshot
    … …  
    228228    ComPtr<IMachine> pMachine;
    229229    /* assume it's a UUID */
    230     rc = a->virtualBox->GetMachine(bstrMachine, pMachine.asOutParam());
     230    rc = a->virtualBox->GetMachine(bstrMachine.raw(), pMachine.asOutParam());
    231231    if (FAILED(rc) || !pMachine)
    232232    {
    233233        /* must be a name */
    234         CHECK_ERROR(a->virtualBox, FindMachine(bstrMachine, pMachine.asOutParam()));
     234        CHECK_ERROR(a->virtualBox, FindMachine(bstrMachine.raw(),
     235                                               pMachine.asOutParam()));
    235236    }
    236237    if (!pMachine)
    … …  
    308309
    309310            ComPtr<IProgress> progress;
    310             CHECK_ERROR_BREAK(console, TakeSnapshot(name, desc, progress.asOutParam()));
     311            CHECK_ERROR_BREAK(console, TakeSnapshot(name.raw(), desc.raw(),
     312                                                    progress.asOutParam()));
    311313
    312314            rc = showProgress(progress);
    … …  
    369371                // assume it's a UUID
    370372                bstrSnapGuid = a->argv[2];
    371                 if (FAILED(pMachine->GetSnapshot(bstrSnapGuid, pSnapshot.asOutParam())))
     373                if (FAILED(pMachine->GetSnapshot(bstrSnapGuid.raw(),
     374                                                 pSnapshot.asOutParam())))
    372375                {
    373376                    // then it must be a name
    374                     CHECK_ERROR_BREAK(pMachine, FindSnapshot(Bstr(a->argv[2]), pSnapshot.asOutParam()));
     377                    CHECK_ERROR_BREAK(pMachine, FindSnapshot(Bstr(a->argv[2]).raw(),
     378                                                             pSnapshot.asOutParam()));
    375379                    CHECK_ERROR_BREAK(pSnapshot, COMGETTER(Id)(bstrSnapGuid.asOutParam()));
    376380                }
    … …  
    379383            if (fDelete)
    380384            {
    381                 CHECK_ERROR_BREAK(console, DeleteSnapshot(bstrSnapGuid, pProgress.asOutParam()));
     385                CHECK_ERROR_BREAK(console, DeleteSnapshot(bstrSnapGuid.raw(),
     386                                                          pProgress.asOutParam()));
    382387            }
    383388            else
    … …  
    417422            {
    418423                /* assume it's a UUID */
    419                 rc = pMachine->GetSnapshot(Bstr(a->argv[2]), snapshot.asOutParam());
     424                rc = pMachine->GetSnapshot(Bstr(a->argv[2]).raw(),
     425                                           snapshot.asOutParam());
    420426                if (FAILED(rc) || !snapshot)
    421427                {
    422428                    /* then it must be a name */
    423                     CHECK_ERROR_BREAK(pMachine, FindSnapshot(Bstr(a->argv[2]), snapshot.asOutParam()));
     429                    CHECK_ERROR_BREAK(pMachine, FindSnapshot(Bstr(a->argv[2]).raw(),
     430                                                             snapshot.asOutParam()));
    424431                }
    425432            }
    … …  
    439446                    }
    440447                    i++;
    441                     snapshot->COMSETTER(Name)(Bstr(a->argv[i]));
     448                    snapshot->COMSETTER(Name)(Bstr(a->argv[i]).raw());
    442449                }
    443450                else if (   !strcmp(a->argv[i], "--description")
    … …  
    452459                    }
    453460                    i++;
    454                     snapshot->COMSETTER(Description)(Bstr(a->argv[i]));
     461                    snapshot->COMSETTER(Description)(Bstr(a->argv[i]).raw());
    455462                }
    456463                else
    … …  
    476483
    477484            /* assume it's a UUID */
    478             rc = pMachine->GetSnapshot(Bstr(a->argv[2]), snapshot.asOutParam());
     485            rc = pMachine->GetSnapshot(Bstr(a->argv[2]).raw(),
     486                                       snapshot.asOutParam());
    479487            if (FAILED(rc) || !snapshot)
    480488            {
    481489                /* then it must be a name */
    482                 CHECK_ERROR_BREAK(pMachine, FindSnapshot(Bstr(a->argv[2]), snapshot.asOutParam()));
     490                CHECK_ERROR_BREAK(pMachine, FindSnapshot(Bstr(a->argv[2]).raw(),
     491                                                         snapshot.asOutParam()));
    483492            }
    484493

  • trunk/src/VBox/Frontends/VBoxManage/VBoxManageStorageController.cpp

    r31615 r32718  
    55
    66/*
    7  * Copyright (C) 2006-2009 Oracle Corporation
     7 * Copyright (C) 2006-2010 Oracle Corporation
    88 *
    99 * This file is part of VirtualBox Open Source Edition (OSE), as
    … …  
    164164    if (!Guid(machineuuid).isEmpty())
    165165    {
    166         CHECK_ERROR_RET(a->virtualBox, GetMachine(machineuuid, machine.asOutParam()), 1);
     166        CHECK_ERROR_RET(a->virtualBox, GetMachine(machineuuid.raw(),
     167                                                  machine.asOutParam()), 1);
    167168    }
    168169    else
    169170    {
    170         CHECK_ERROR_RET(a->virtualBox, FindMachine(Bstr(a->argv[0]), machine.asOutParam()), 1);
     171        CHECK_ERROR_RET(a->virtualBox, FindMachine(Bstr(a->argv[0]).raw(),
     172                                                   machine.asOutParam()), 1);
    171173        machine->COMGETTER(Id)(machineuuid.asOutParam());
    172174    }
    … …  
    200202
    201203    /* check if the storage controller is present */
    202     rc = machine->GetStorageControllerByName(Bstr(pszCtl), storageCtl.asOutParam());
     204    rc = machine->GetStorageControllerByName(Bstr(pszCtl).raw(),
     205                                             storageCtl.asOutParam());
    203206    if (FAILED(rc))
    204207    {
    … …  
    226229    if (!RTStrICmp(pszMedium, "none"))
    227230    {
    228         CHECK_ERROR(machine, DetachDevice(Bstr(pszCtl), port, device));
     231        CHECK_ERROR(machine, DetachDevice(Bstr(pszCtl).raw(), port, device));
    229232    }
    230233    else if (!RTStrICmp(pszMedium, "emptydrive"))
    … …  
    234237            ComPtr<IMediumAttachment> mediumAttachment;
    235238            DeviceType_T deviceType = DeviceType_Null;
    236             rc = machine->GetMediumAttachment(Bstr(pszCtl), port, device, mediumAttachment.asOutParam());
     239            rc = machine->GetMediumAttachment(Bstr(pszCtl).raw(), port, device,
     240                                              mediumAttachment.asOutParam());
    237241            if (SUCCEEDED(rc))
    238242            {
    … …  
    243247                {
    244248                    /* just unmount the floppy/dvd */
    245                     CHECK_ERROR(machine, MountMedium(Bstr(pszCtl), port, device, Bstr(""), fForceUnmount));
     249                    CHECK_ERROR(machine, MountMedium(Bstr(pszCtl).raw(), port,
     250                                                     device, Bstr("").raw(),
     251                                                     fForceUnmount));
    246252                }
    247253            }
    … …  
    286292
    287293            /* attach a empty floppy/dvd drive after removing previous attachment */
    288             machine->DetachDevice(Bstr(pszCtl), port, device);
    289             CHECK_ERROR(machine, AttachDevice(Bstr(pszCtl), port, device, deviceType, NULL));
     294            machine->DetachDevice(Bstr(pszCtl).raw(), port, device);
     295            CHECK_ERROR(machine, AttachDevice(Bstr(pszCtl).raw(), port, device,
     296                                              deviceType, NULL));
    290297        }
    291298    }
    … …  
    319326                 */
    320327                ComPtr<IMediumAttachment> mediumAttachement;
    321                 rc = machine->GetMediumAttachment(Bstr(pszCtl), port, device, mediumAttachement.asOutParam());
     328                rc = machine->GetMediumAttachment(Bstr(pszCtl).raw(), port,
     329                                                  device,
     330                                                  mediumAttachement.asOutParam());
    322331                if (SUCCEEDED(rc))
    323332                {
    … …  
    328337                    {
    329338                        ComPtr<IMedium> dvdMedium;
    330                         rc = a->virtualBox->FindMedium(Bstr(pszMedium), DeviceType_DVD, dvdMedium.asOutParam());
     339                        rc = a->virtualBox->FindMedium(Bstr(pszMedium).raw(),
     340                                                       DeviceType_DVD,
     341                                                       dvdMedium.asOutParam());
    331342                        if (dvdMedium)
    332343                            /*
    … …  
    339350                    {
    340351                        ComPtr<IMedium> hardDisk;
    341                         rc = a->virtualBox->FindMedium(Bstr(pszMedium), DeviceType_HardDisk, hardDisk.asOutParam());
     352                        rc = a->virtualBox->FindMedium(Bstr(pszMedium).raw(),
     353                                                       DeviceType_HardDisk,
     354                                                       hardDisk.asOutParam());
    342355                        if (hardDisk)
    343356                            /*
    … …  
    402415
    403416                /* check if there is a dvd drive at the given location, if not attach one */
    404                 rc = machine->GetMediumAttachment(Bstr(pszCtl), port, device, mediumAttachement.asOutParam());
     417                rc = machine->GetMediumAttachment(Bstr(pszCtl).raw(), port,
     418                                                  device,
     419                                                  mediumAttachement.asOutParam());
    405420                if (SUCCEEDED(rc))
    406421                {
    … …  
    410425                    if (deviceType != DeviceType_DVD)
    411426                    {
    412                         machine->DetachDevice(Bstr(pszCtl), port, device);
    413                         rc = machine->AttachDevice(Bstr(pszCtl), port, device, DeviceType_DVD, NULL);
     427                        machine->DetachDevice(Bstr(pszCtl).raw(), port, device);
     428                        rc = machine->AttachDevice(Bstr(pszCtl).raw(), port,
     429                                                   device, DeviceType_DVD, NULL);
    414430                    }
    415431                }
    416432                else
    417433                {
    418                     rc = machine->AttachDevice(Bstr(pszCtl), port, device, DeviceType_DVD, NULL);
     434                    rc = machine->AttachDevice(Bstr(pszCtl).raw(), port,
     435                                               device, DeviceType_DVD, NULL);
    419436                }
    420437            }
    … …  
    428445                    ComPtr<IHost> host;
    429446                    CHECK_ERROR(a->virtualBox, COMGETTER(Host)(host.asOutParam()));
    430                     rc = host->FindHostDVDDrive(Bstr(pszMedium + 5), dvdMedium.asOutParam());
     447                    rc = host->FindHostDVDDrive(Bstr(pszMedium + 5).raw(),
     448                                                dvdMedium.asOutParam());
    431449                    if (!dvdMedium)
    432450                    {
    … …  
    439457                            break;
    440458                        }
    441                         rc = host->FindHostDVDDrive(Bstr(szPathReal), dvdMedium.asOutParam());
     459                        rc = host->FindHostDVDDrive(Bstr(szPathReal).raw(),
     460                                                    dvdMedium.asOutParam());
    442461                        if (!dvdMedium)
    443462                        {
    … …  
    450469                else
    451470                {
    452                     rc = a->virtualBox->FindMedium(Bstr(pszMedium), DeviceType_DVD, dvdMedium.asOutParam());
     471                    rc = a->virtualBox->FindMedium(Bstr(pszMedium).raw(),
     472                                                   DeviceType_DVD,
     473                                                   dvdMedium.asOutParam());
    453474                    if (FAILED(rc) || !dvdMedium)
    454475                    {
    … …  
    456477                        Bstr emptyUUID;
    457478                        CHECK_ERROR(a->virtualBox,
    458                                     OpenMedium(Bstr(pszMedium),
     479                                    OpenMedium(Bstr(pszMedium).raw(),
    459480                                               DeviceType_DVD,
    460481                                               AccessMode_ReadWrite,
    … …  
    473494            {
    474495                dvdMedium->COMGETTER(Id)(uuid.asOutParam());
    475                 CHECK_ERROR(machine, MountMedium(Bstr(pszCtl), port, device, uuid, fForceUnmount));
     496                CHECK_ERROR(machine, MountMedium(Bstr(pszCtl).raw(), port,
     497                                                 device, uuid.raw(),
     498                                                 fForceUnmount));
    476499            }
    477500        }
    … …  
    482505
    483506            /* if there is anything attached at the given location, remove it */
    484             machine->DetachDevice(Bstr(pszCtl), port, device);
     507            machine->DetachDevice(Bstr(pszCtl).raw(), port, device);
    485508
    486509            /* first guess is that it's a UUID */
    487510            ComPtr<IMedium> hardDisk;
    488             rc = a->virtualBox->FindMedium(Bstr(pszMedium), DeviceType_HardDisk, hardDisk.asOutParam());
     511            rc = a->virtualBox->FindMedium(Bstr(pszMedium).raw(),
     512                                           DeviceType_HardDisk,
     513                                           hardDisk.asOutParam());
    489514
    490515            /* not successful? Then it must be a filename */
    … …  
    493518                /* open the new hard disk object */
    494519                CHECK_ERROR(a->virtualBox,
    495                             OpenMedium(Bstr(pszMedium),
     520                            OpenMedium(Bstr(pszMedium).raw(),
    496521                                       DeviceType_HardDisk,
    497522                                       AccessMode_ReadWrite,
    … …  
    501526            if (hardDisk)
    502527            {
    503                 CHECK_ERROR(machine, AttachDevice(Bstr(pszCtl), port, device, DeviceType_HardDisk, hardDisk));
     528                CHECK_ERROR(machine, AttachDevice(Bstr(pszCtl).raw(), port,
     529                                                  device, DeviceType_HardDisk,
     530                                                  hardDisk));
    504531            }
    505532            else
    … …  
    514541            ComPtr<IMedium> floppyMedium;
    515542            ComPtr<IMediumAttachment> floppyAttachment;
    516             machine->GetMediumAttachment(Bstr(pszCtl), port, device, floppyAttachment.asOutParam());
     543            machine->GetMediumAttachment(Bstr(pszCtl).raw(), port, device,
     544                                         floppyAttachment.asOutParam());
    517545
    518546            if (   !fRunTime
    519547                && !floppyAttachment)
    520                 CHECK_ERROR(machine, AttachDevice(Bstr(pszCtl), port, device, DeviceType_Floppy, NULL));
     548                CHECK_ERROR(machine, AttachDevice(Bstr(pszCtl).raw(), port,
     549                                                  device, DeviceType_Floppy,
     550                                                  NULL));
    521551
    522552            /* host drive? */
    … …  
    526556
    527557                CHECK_ERROR(a->virtualBox, COMGETTER(Host)(host.asOutParam()));
    528                 rc = host->FindHostFloppyDrive(Bstr(pszMedium + 5), floppyMedium.asOutParam());
     558                rc = host->FindHostFloppyDrive(Bstr(pszMedium + 5).raw(),
     559                                               floppyMedium.asOutParam());
    529560                if (!floppyMedium)
    530561                {
    … …  
    536567            {
    537568                /* first assume it's a UUID */
    538                 rc = a->virtualBox->FindMedium(Bstr(pszMedium), DeviceType_Floppy, floppyMedium.asOutParam());
     569                rc = a->virtualBox->FindMedium(Bstr(pszMedium).raw(),
     570                                               DeviceType_Floppy,
     571                                               floppyMedium.asOutParam());
    539572                if (FAILED(rc) || !floppyMedium)
    540573                {
    … …  
    542575                    Bstr emptyUUID;
    543576                    CHECK_ERROR(a->virtualBox,
    544                                  OpenMedium(Bstr(pszMedium),
     577                                 OpenMedium(Bstr(pszMedium).raw(),
    545578                                            DeviceType_Floppy,
    546579                                            AccessMode_ReadWrite,
    … …  
    558591            {
    559592                floppyMedium->COMGETTER(Id)(uuid.asOutParam());
    560                 CHECK_ERROR(machine, MountMedium(Bstr(pszCtl), port, device, uuid, fForceUnmount));
     593                CHECK_ERROR(machine, MountMedium(Bstr(pszCtl).raw(), port,
     594                                                 device, uuid.raw(),
     595                                                 fForceUnmount));
    561596            }
    562597        }
    … …  
    573608        ComPtr<IMediumAttachment> mattach;
    574609
    575         CHECK_ERROR(machine, GetMediumAttachment(Bstr(pszCtl), port, device, mattach.asOutParam()));
     610        CHECK_ERROR(machine, GetMediumAttachment(Bstr(pszCtl).raw(), port,
     611                                                 device, mattach.asOutParam()));
    576612
    577613        if (SUCCEEDED(rc))
    … …  
    579615            if (!RTStrICmp(pszPassThrough, "on"))
    580616            {
    581                 CHECK_ERROR(machine, PassthroughDevice(Bstr(pszCtl), port, device, TRUE));
     617                CHECK_ERROR(machine, PassthroughDevice(Bstr(pszCtl).raw(),
     618                                                       port, device, TRUE));
    582619            }
    583620            else if (!RTStrICmp(pszPassThrough, "off"))
    584621            {
    585                 CHECK_ERROR(machine, PassthroughDevice(Bstr(pszCtl), port, device, FALSE));
     622                CHECK_ERROR(machine, PassthroughDevice(Bstr(pszCtl).raw(),
     623                                                       port, device, FALSE));
    586624            }
    587625            else
    … …  
    716754    if (!Guid(machineuuid).isEmpty())
    717755    {
    718         CHECK_ERROR_RET(a->virtualBox, GetMachine (machineuuid, machine.asOutParam()), 1);
     756        CHECK_ERROR_RET(a->virtualBox, GetMachine(machineuuid.raw(),
     757                                                  machine.asOutParam()), 1);
    719758    }
    720759    else
    721760    {
    722         CHECK_ERROR_RET(a->virtualBox, FindMachine(Bstr(a->argv[0]), machine.asOutParam()), 1);
     761        CHECK_ERROR_RET(a->virtualBox, FindMachine(Bstr(a->argv[0]).raw(),
     762                                                   machine.asOutParam()), 1);
    723763        machine->COMGETTER(Id)(machineuuid.asOutParam());
    724764    }
    … …  
    743783
    744784        CHECK_ERROR(machine,
    745                      GetMediumAttachmentsOfController(Bstr(pszCtl),
     785                     GetMediumAttachmentsOfController(Bstr(pszCtl).raw(),
    746786                                                      ComSafeArrayAsOutParam(mediumAttachments)));
    747787        for (size_t i = 0; i < mediumAttachments.size(); ++ i)
    … …  
    753793            CHECK_ERROR(mediumAttach, COMGETTER(Port)(&port));
    754794            CHECK_ERROR(mediumAttach, COMGETTER(Device)(&device));
    755             CHECK_ERROR(machine, DetachDevice(Bstr(pszCtl), port, device));
     795            CHECK_ERROR(machine, DetachDevice(Bstr(pszCtl).raw(), port, device));
    756796        }
    757797
    758798        if (SUCCEEDED(rc))
    759             CHECK_ERROR(machine, RemoveStorageController(Bstr(pszCtl)));
     799            CHECK_ERROR(machine, RemoveStorageController(Bstr(pszCtl).raw()));
    760800        else
    761801            errorArgument("Can't detach the devices connected to '%s' Controller\n"
    … …  
    770810            if (!RTStrICmp(pszBusType, "ide"))
    771811            {
    772                 CHECK_ERROR(machine, AddStorageController(Bstr(pszCtl), StorageBus_IDE, ctl.asOutParam()));
     812                CHECK_ERROR(machine, AddStorageController(Bstr(pszCtl).raw(),
     813                                                          StorageBus_IDE,
     814                                                          ctl.asOutParam()));
    773815            }
    774816            else if (!RTStrICmp(pszBusType, "sata"))
    775817            {
    776                 CHECK_ERROR(machine, AddStorageController(Bstr(pszCtl), StorageBus_SATA, ctl.asOutParam()));
     818                CHECK_ERROR(machine, AddStorageController(Bstr(pszCtl).raw(),
     819                                                          StorageBus_SATA,
     820                                                          ctl.asOutParam()));
    777821            }
    778822            else if (!RTStrICmp(pszBusType, "scsi"))
    779823            {
    780                 CHECK_ERROR(machine, AddStorageController(Bstr(pszCtl), StorageBus_SCSI, ctl.asOutParam()));
     824                CHECK_ERROR(machine, AddStorageController(Bstr(pszCtl).raw(),
     825                                                          StorageBus_SCSI,
     826                                                          ctl.asOutParam()));
    781827            }
    782828            else if (!RTStrICmp(pszBusType, "floppy"))
    783829            {
    784                 CHECK_ERROR(machine, AddStorageController(Bstr(pszCtl), StorageBus_Floppy, ctl.asOutParam()));
     830                CHECK_ERROR(machine, AddStorageController(Bstr(pszCtl).raw(),
     831                                                          StorageBus_Floppy,
     832                                                          ctl.asOutParam()));
    785833            }
    786834            else if (!RTStrICmp(pszBusType, "sas"))
    787835            {
    788                 CHECK_ERROR(machine, AddStorageController(Bstr(pszCtl), StorageBus_SAS, ctl.asOutParam()));
     836                CHECK_ERROR(machine, AddStorageController(Bstr(pszCtl).raw(),
     837                                                          StorageBus_SAS,
     838                                                          ctl.asOutParam()));
    789839            }
    790840            else
    … …  
    800850            ComPtr<IStorageController> ctl;
    801851
    802             CHECK_ERROR(machine, GetStorageControllerByName(Bstr(pszCtl), ctl.asOutParam()));
     852            CHECK_ERROR(machine, GetStorageControllerByName(Bstr(pszCtl).raw(),
     853                                                            ctl.asOutParam()));
    803854
    804855            if (SUCCEEDED(rc))
    … …  
    854905            ComPtr<IStorageController> ctl;
    855906
    856             CHECK_ERROR(machine, GetStorageControllerByName(Bstr(pszCtl), ctl.asOutParam()));
     907            CHECK_ERROR(machine, GetStorageControllerByName(Bstr(pszCtl).raw(),
     908                                                            ctl.asOutParam()));
    857909
    858910            if (SUCCEEDED(rc))
    … …  
    873925            ComPtr<IStorageController> ctl;
    874926
    875             CHECK_ERROR(machine, GetStorageControllerByName(Bstr(pszCtl), ctl.asOutParam()));
     927            CHECK_ERROR(machine, GetStorageControllerByName(Bstr(pszCtl).raw(),
     928                                                            ctl.asOutParam()));
    876929
    877930            if (SUCCEEDED(rc))
    … …  
    891944            ComPtr<IStorageController> ctl;
    892945
    893             CHECK_ERROR(machine, GetStorageControllerByName(Bstr(pszCtl), ctl.asOutParam()));
     946            CHECK_ERROR(machine, GetStorageControllerByName(Bstr(pszCtl).raw(),
     947                                                            ctl.asOutParam()));
    894948
    895949            if (SUCCEEDED(rc))

  • trunk/src/VBox/Frontends/VBoxManage/VBoxManageUSB.cpp

    r31070 r32718  
    55
    66/*
    7  * Copyright (C) 2006-2009 Oracle Corporation
     7 * Copyright (C) 2006-2010 Oracle Corporation
    88 *
    99 * This file is part of VirtualBox Open Source Edition (OSE), as
    … …  
    122122public:
    123123
    124     Nullable() : mIsNull (true) {}
    125     Nullable (const T &aValue, bool aIsNull = false)
    126         : mIsNull (aIsNull), mValue (aValue) {}
     124    Nullable() : mIsNull(true) {}
     125    Nullable(const T &aValue, bool aIsNull = false)
     126        : mIsNull(aIsNull), mValue(aValue) {}
    127127
    128128    bool isNull() const { return mIsNull; };
    129     void setNull (bool aIsNull = true) { mIsNull = aIsNull; }
     129    void setNull(bool aIsNull = true) { mIsNull = aIsNull; }
    130130
    131131    operator const T&() const { return mValue; }
    … …  
    149149    struct USBFilter
    150150    {
    151         USBFilter ()
    152             : mAction (USBDeviceFilterAction_Null)
     151        USBFilter()
     152            : mAction(USBDeviceFilterAction_Null)
    153153            {}
    154154
    … …  
    168168    enum Action { Invalid, Add, Modify, Remove };
    169169
    170     USBFilterCmd() : mAction (Invalid), mIndex (0), mGlobal (false) {}
     170    USBFilterCmd() : mAction(Invalid), mIndex(0), mGlobal(false) {}
    171171
    172172    Action mAction;
    … …  
    179179};
    180180
    181 int handleUSBFilter (HandlerArg *a)
     181int handleUSBFilter(HandlerArg *a)
    182182{
    183183    HRESULT rc = S_OK;
    … …  
    198198
    199199    /* which index? */
    200     if (VINF_SUCCESS !=  RTStrToUInt32Full (a->argv[1], 10, &cmd.mIndex))
     200    if (VINF_SUCCESS !=  RTStrToUInt32Full(a->argv[1], 10, &cmd.mIndex))
    201201        return errorSyntax(USAGE_USBFILTER, "Invalid index '%s'", a->argv[1]);
    202202
    … …  
    234234                    {
    235235                        /* assume it's a UUID of a machine */
    236                         rc = a->virtualBox->GetMachine(Bstr(a->argv[i]), cmd.mMachine.asOutParam());
     236                        rc = a->virtualBox->GetMachine(Bstr(a->argv[i]).raw(),
     237                                                       cmd.mMachine.asOutParam());
    237238                        if (FAILED(rc) || !cmd.mMachine)
    238239                        {
    239240                            /* must be a name */
    240                             CHECK_ERROR_RET(a->virtualBox, FindMachine(Bstr(a->argv[i]), cmd.mMachine.asOutParam()), 1);
     241                            CHECK_ERROR_RET(a->virtualBox, FindMachine(Bstr(a->argv[i]).raw(),
     242                                                                       cmd.mMachine.asOutParam()), 1);
    241243                        }
    242244                    }
    … …  
    360362                        && !cmd.mMachine)
    361363                    || (   cmd.mGlobal
    362                         && cmd.mFilter.mRemote)
     364                        && !cmd.mFilter.mRemote.isEmpty())
    363365                   )
    364366                {
    … …  
    388390                    {
    389391                        /* assume it's a UUID of a machine */
    390                         rc = a->virtualBox->GetMachine(Bstr(a->argv[i]), cmd.mMachine.asOutParam());
     392                        rc = a->virtualBox->GetMachine(Bstr(a->argv[i]).raw(),
     393                                                       cmd.mMachine.asOutParam());
    391394                        if (FAILED(rc) || !cmd.mMachine)
    392395                        {
    393396                            /* must be a name */
    394                             CHECK_ERROR_RET(a->virtualBox, FindMachine(Bstr(a->argv[i]), cmd.mMachine.asOutParam()), 1);
     397                            CHECK_ERROR_RET(a->virtualBox, FindMachine(Bstr(a->argv[i]).raw(),
     398                                                                       cmd.mMachine.asOutParam()), 1);
    395399                        }
    396400                    }
    … …  
    413417    ComPtr <IUSBController> ctl;
    414418    if (cmd.mGlobal)
    415         CHECK_ERROR_RET (a->virtualBox, COMGETTER(Host) (host.asOutParam()), 1);
     419        CHECK_ERROR_RET(a->virtualBox, COMGETTER(Host)(host.asOutParam()), 1);
    416420    else
    417421    {
    … …  
    431435            {
    432436                ComPtr <IHostUSBDeviceFilter> flt;
    433                 CHECK_ERROR_BREAK (host, CreateUSBDeviceFilter (f.mName, flt.asOutParam()));
     437                CHECK_ERROR_BREAK(host, CreateUSBDeviceFilter(f.mName.raw(),
     438                                                              flt.asOutParam()));
    434439
    435440                if (!f.mActive.isNull())
    436                     CHECK_ERROR_BREAK (flt, COMSETTER(Active) (f.mActive));
     441                    CHECK_ERROR_BREAK(flt, COMSETTER(Active)(f.mActive));
    437442                if (!f.mVendorId.isEmpty())
    438                     CHECK_ERROR_BREAK (flt, COMSETTER(VendorId) (f.mVendorId));
     443                    CHECK_ERROR_BREAK(flt, COMSETTER(VendorId)(f.mVendorId.raw()));
    439444                if (!f.mProductId.isEmpty())
    440                     CHECK_ERROR_BREAK (flt, COMSETTER(ProductId) (f.mProductId));
     445                    CHECK_ERROR_BREAK(flt, COMSETTER(ProductId)(f.mProductId.raw()));
    441446                if (!f.mRevision.isEmpty())
    442                     CHECK_ERROR_BREAK (flt, COMSETTER(Revision) (f.mRevision));
     447                    CHECK_ERROR_BREAK(flt, COMSETTER(Revision)(f.mRevision.raw()));
    443448                if (!f.mManufacturer.isEmpty())
    444                     CHECK_ERROR_BREAK (flt, COMSETTER(Manufacturer) (f.mManufacturer));
     449                    CHECK_ERROR_BREAK(flt, COMSETTER(Manufacturer)(f.mManufacturer.raw()));
    445450                if (!f.mSerialNumber.isEmpty())
    446                     CHECK_ERROR_BREAK (flt, COMSETTER(SerialNumber) (f.mSerialNumber));
     451                    CHECK_ERROR_BREAK(flt, COMSETTER(SerialNumber)(f.mSerialNumber.raw()));
    447452                if (!f.mMaskedInterfaces.isNull())
    448                     CHECK_ERROR_BREAK (flt, COMSETTER(MaskedInterfaces) (f.mMaskedInterfaces));
     453                    CHECK_ERROR_BREAK(flt, COMSETTER(MaskedInterfaces)(f.mMaskedInterfaces));
    449454
    450455                if (f.mAction != USBDeviceFilterAction_Null)
    451                     CHECK_ERROR_BREAK (flt, COMSETTER(Action) (f.mAction));
    452 
    453                 CHECK_ERROR_BREAK (host, InsertUSBDeviceFilter (cmd.mIndex, flt));
     456                    CHECK_ERROR_BREAK(flt, COMSETTER(Action)(f.mAction));
     457
     458                CHECK_ERROR_BREAK(host, InsertUSBDeviceFilter(cmd.mIndex, flt));
    454459            }
    455460            else
    456461            {
    457462                ComPtr <IUSBDeviceFilter> flt;
    458                 CHECK_ERROR_BREAK (ctl, CreateDeviceFilter (f.mName, flt.asOutParam()));
     463                CHECK_ERROR_BREAK(ctl, CreateDeviceFilter(f.mName.raw(),
     464                                                          flt.asOutParam()));
    459465
    460466                if (!f.mActive.isNull())
    461                     CHECK_ERROR_BREAK (flt, COMSETTER(Active) (f.mActive));
     467                    CHECK_ERROR_BREAK(flt, COMSETTER(Active)(f.mActive));
    462468                if (!f.mVendorId.isEmpty())
    463                     CHECK_ERROR_BREAK (flt, COMSETTER(VendorId) (f.mVendorId));
     469                    CHECK_ERROR_BREAK(flt, COMSETTER(VendorId)(f.mVendorId.raw()));
    464470                if (!f.mProductId.isEmpty())
    465                     CHECK_ERROR_BREAK (flt, COMSETTER(ProductId) (f.mProductId));
     471                    CHECK_ERROR_BREAK(flt, COMSETTER(ProductId)(f.mProductId.raw()));
    466472                if (!f.mRevision.isEmpty())
    467                     CHECK_ERROR_BREAK (flt, COMSETTER(Revision) (f.mRevision));
     473                    CHECK_ERROR_BREAK(flt, COMSETTER(Revision)(f.mRevision.raw()));
    468474                if (!f.mManufacturer.isEmpty())
    469                     CHECK_ERROR_BREAK (flt, COMSETTER(Manufacturer) (f.mManufacturer));
     475                    CHECK_ERROR_BREAK(flt, COMSETTER(Manufacturer)(f.mManufacturer.raw()));
    470476                if (!f.mRemote.isEmpty())
    471                     CHECK_ERROR_BREAK (flt, COMSETTER(Remote) (f.mRemote));
     477                    CHECK_ERROR_BREAK(flt, COMSETTER(Remote)(f.mRemote.raw()));
    472478                if (!f.mSerialNumber.isEmpty())
    473                     CHECK_ERROR_BREAK (flt, COMSETTER(SerialNumber) (f.mSerialNumber));
     479                    CHECK_ERROR_BREAK(flt, COMSETTER(SerialNumber)(f.mSerialNumber.raw()));
    474480                if (!f.mMaskedInterfaces.isNull())
    475                     CHECK_ERROR_BREAK (flt, COMSETTER(MaskedInterfaces) (f.mMaskedInterfaces));
    476 
    477                 CHECK_ERROR_BREAK (ctl, InsertDeviceFilter (cmd.mIndex, flt));
     481                    CHECK_ERROR_BREAK(flt, COMSETTER(MaskedInterfaces)(f.mMaskedInterfaces));
     482
     483                CHECK_ERROR_BREAK(ctl, InsertDeviceFilter(cmd.mIndex, flt));
    478484            }
    479485            break;
    … …  
    484490            {
    485491                SafeIfaceArray <IHostUSBDeviceFilter> coll;
    486                 CHECK_ERROR_BREAK (host, COMGETTER(USBDeviceFilters) (ComSafeArrayAsOutParam(coll)));
     492                CHECK_ERROR_BREAK(host, COMGETTER(USBDeviceFilters)(ComSafeArrayAsOutParam(coll)));
    487493
    488494                ComPtr <IHostUSBDeviceFilter> flt = coll[cmd.mIndex];
    489495
    490496                if (!f.mName.isEmpty())
    491                     CHECK_ERROR_BREAK (flt, COMSETTER(Name) (f.mName));
     497                    CHECK_ERROR_BREAK(flt, COMSETTER(Name)(f.mName.raw()));
    492498                if (!f.mActive.isNull())
    493                     CHECK_ERROR_BREAK (flt, COMSETTER(Active) (f.mActive));
     499                    CHECK_ERROR_BREAK(flt, COMSETTER(Active)(f.mActive));
    494500                if (!f.mVendorId.isEmpty())
    495                     CHECK_ERROR_BREAK (flt, COMSETTER(VendorId) (f.mVendorId));
     501                    CHECK_ERROR_BREAK(flt, COMSETTER(VendorId)(f.mVendorId.raw()));
    496502                if (!f.mProductId.isEmpty())
    497                     CHECK_ERROR_BREAK (flt, COMSETTER(ProductId) (f.mProductId));
     503                    CHECK_ERROR_BREAK(flt, COMSETTER(ProductId)(f.mProductId.raw()));
    498504                if (!f.mRevision.isEmpty())
    499                     CHECK_ERROR_BREAK (flt, COMSETTER(Revision) (f.mRevision));
     505                    CHECK_ERROR_BREAK(flt, COMSETTER(Revision)(f.mRevision.raw()));
    500506                if (!f.mManufacturer.isEmpty())
    501                     CHECK_ERROR_BREAK (flt, COMSETTER(Manufacturer) (f.mManufacturer));
     507                    CHECK_ERROR_BREAK(flt, COMSETTER(Manufacturer)(f.mManufacturer.raw()));
    502508                if (!f.mSerialNumber.isEmpty())
    503                     CHECK_ERROR_BREAK (flt, COMSETTER(SerialNumber) (f.mSerialNumber));
     509                    CHECK_ERROR_BREAK(flt, COMSETTER(SerialNumber)(f.mSerialNumber.raw()));
    504510                if (!f.mMaskedInterfaces.isNull())
    505                     CHECK_ERROR_BREAK (flt, COMSETTER(MaskedInterfaces) (f.mMaskedInterfaces));
     511                    CHECK_ERROR_BREAK(flt, COMSETTER(MaskedInterfaces)(f.mMaskedInterfaces));
    506512
    507513                if (f.mAction != USBDeviceFilterAction_Null)
    508                     CHECK_ERROR_BREAK (flt, COMSETTER(Action) (f.mAction));
     514                    CHECK_ERROR_BREAK(flt, COMSETTER(Action)(f.mAction));
    509515            }
    510516            else
    511517            {
    512518                SafeIfaceArray <IUSBDeviceFilter> coll;
    513                 CHECK_ERROR_BREAK (ctl, COMGETTER(DeviceFilters) (ComSafeArrayAsOutParam(coll)));
     519                CHECK_ERROR_BREAK(ctl, COMGETTER(DeviceFilters)(ComSafeArrayAsOutParam(coll)));
    514520
    515521                ComPtr <IUSBDeviceFilter> flt = coll[cmd.mIndex];
    516522
    517523                if (!f.mName.isEmpty())
    518                     CHECK_ERROR_BREAK (flt, COMSETTER(Name) (f.mName));
     524                    CHECK_ERROR_BREAK(flt, COMSETTER(Name)(f.mName.raw()));
    519525                if (!f.mActive.isNull())
    520                     CHECK_ERROR_BREAK (flt, COMSETTER(Active) (f.mActive));
     526                    CHECK_ERROR_BREAK(flt, COMSETTER(Active)(f.mActive));
    521527                if (!f.mVendorId.isEmpty())
    522                     CHECK_ERROR_BREAK (flt, COMSETTER(VendorId) (f.mVendorId));
     528                    CHECK_ERROR_BREAK(flt, COMSETTER(VendorId)(f.mVendorId.raw()));
    523529                if (!f.mProductId.isEmpty())
    524                     CHECK_ERROR_BREAK (flt, COMSETTER(ProductId) (f.mProductId));
     530                    CHECK_ERROR_BREAK(flt, COMSETTER(ProductId)(f.mProductId.raw()));
    525531                if (!f.mRevision.isEmpty())
    526                     CHECK_ERROR_BREAK (flt, COMSETTER(Revision) (f.mRevision));
     532                    CHECK_ERROR_BREAK(flt, COMSETTER(Revision)(f.mRevision.raw()));
    527533                if (!f.mManufacturer.isEmpty())
    528                     CHECK_ERROR_BREAK (flt, COMSETTER(Manufacturer) (f.mManufacturer));
     534                    CHECK_ERROR_BREAK(flt, COMSETTER(Manufacturer)(f.mManufacturer.raw()));
    529535                if (!f.mRemote.isEmpty())
    530                     CHECK_ERROR_BREAK (flt, COMSETTER(Remote) (f.mRemote));
     536                    CHECK_ERROR_BREAK(flt, COMSETTER(Remote)(f.mRemote.raw()));
    531537                if (!f.mSerialNumber.isEmpty())
    532                     CHECK_ERROR_BREAK (flt, COMSETTER(SerialNumber) (f.mSerialNumber));
     538                    CHECK_ERROR_BREAK(flt, COMSETTER(SerialNumber)(f.mSerialNumber.raw()));
    533539                if (!f.mMaskedInterfaces.isNull())
    534                     CHECK_ERROR_BREAK (flt, COMSETTER(MaskedInterfaces) (f.mMaskedInterfaces));
     540                    CHECK_ERROR_BREAK(flt, COMSETTER(MaskedInterfaces)(f.mMaskedInterfaces));
    535541            }
    536542            break;
    … …  
    541547            {
    542548                ComPtr <IHostUSBDeviceFilter> flt;
    543                 CHECK_ERROR_BREAK (host, RemoveUSBDeviceFilter (cmd.mIndex));
     549                CHECK_ERROR_BREAK(host, RemoveUSBDeviceFilter(cmd.mIndex));
    544550            }
    545551            else
    546552            {
    547553                ComPtr <IUSBDeviceFilter> flt;
    548                 CHECK_ERROR_BREAK (ctl, RemoveDeviceFilter (cmd.mIndex, flt.asOutParam()));
     554                CHECK_ERROR_BREAK(ctl, RemoveDeviceFilter(cmd.mIndex, flt.asOutParam()));
    549555            }
    550556            break;
    … …  
    556562    if (cmd.mMachine)
    557563    {
    558         if (SUCCEEDED (rc))
     564        if (SUCCEEDED(rc))
    559565        {
    560566            /* commit the session */
    … …  
    565571    }
    566572
    567     return SUCCEEDED (rc) ? 0 : 1;
     573    return SUCCEEDED(rc) ? 0 : 1;
    568574}
    569575/* vi: set tabstop=4 shiftwidth=4 expandtab: */

  • trunk/src/VBox/Frontends/VBoxSDL/VBoxSDL.cpp

    r31698 r32718  
    291291                        Bstr keyString;
    292292                        edcev->COMGETTER(Key)(keyString.asOutParam());
    293                         if (keyString && keyString == VBOXSDL_SECURELABEL_EXTRADATA)
     293                        if (keyString == VBOXSDL_SECURELABEL_EXTRADATA)
    294294                        {
    295295                            /*
    … …  
    13421342    {
    13431343        Bstr  bstrVMName = vmName;
    1344         rc = virtualBox->FindMachine(bstrVMName, pMachine.asOutParam());
     1344        rc = virtualBox->FindMachine(bstrVMName.raw(), pMachine.asOutParam());
    13451345        if ((rc == S_OK) && pMachine)
    13461346        {
    … …  
    14131413        Bstr hdaFileBstr = hdaFile;
    14141414        ComPtr<IMedium> hardDisk;
    1415         virtualBox->FindMedium(hdaFileBstr, DeviceType_HardDisk, hardDisk.asOutParam());
     1415        virtualBox->FindMedium(hdaFileBstr.raw(), DeviceType_HardDisk,
     1416                               hardDisk.asOutParam());
    14161417        if (!hardDisk)
    14171418        {
    14181419            /* we've not found the image */
    14191420            RTPrintf("Adding hard disk '%S'...\n", hdaFile);
    1420             virtualBox->OpenMedium(hdaFileBstr, DeviceType_HardDisk, AccessMode_ReadWrite, hardDisk.asOutParam());
     1421            virtualBox->OpenMedium(hdaFileBstr.raw(), DeviceType_HardDisk,
     1422                                   AccessMode_ReadWrite, hardDisk.asOutParam());
    14211423        }
    14221424        /* do we have the right image now? */
    … …  
    14501452                {
    14511453                    CHECK_ERROR(storageCtl, COMGETTER(Name)(storageCtlName.asOutParam()));
    1452                     gMachine->DetachDevice(storageCtlName, 0, 0);
     1454                    gMachine->DetachDevice(storageCtlName.raw(), 0, 0);
    14531455                }
    14541456                else
    14551457                {
    14561458                    storageCtlName = "IDE Controller";
    1457                     CHECK_ERROR(gMachine, AddStorageController(storageCtlName,
    1458                                                                 StorageBus_IDE,
    1459                                                                 storageCtl.asOutParam()));
     1459                    CHECK_ERROR(gMachine, AddStorageController(storageCtlName.raw(),
     1460                                                               StorageBus_IDE,
     1461                                                               storageCtl.asOutParam()));
    14601462                }
    14611463            }
    14621464
    1463             gMachine->AttachDevice(storageCtlName, 0, 0, DeviceType_HardDisk, hardDisk);
     1465            gMachine->AttachDevice(storageCtlName.raw(), 0, 0,
     1466                                   DeviceType_HardDisk, hardDisk);
    14641467            /// @todo why is this attachment saved?
    14651468        }
    … …  
    14911494            ComPtr <IHost> host;
    14921495            CHECK_ERROR_BREAK(virtualBox, COMGETTER(Host)(host.asOutParam()));
    1493             rc = host->FindHostFloppyDrive(medium, floppyMedium.asOutParam());
     1496            rc = host->FindHostFloppyDrive(medium.raw(),
     1497                                           floppyMedium.asOutParam());
    14941498            if (FAILED(rc))
    14951499            {
    14961500                /* try to find an existing one */
    1497                 rc = virtualBox->FindMedium(medium, DeviceType_Floppy, floppyMedium.asOutParam());
     1501                rc = virtualBox->FindMedium(medium.raw(), DeviceType_Floppy,
     1502                                            floppyMedium.asOutParam());
    14981503                if (FAILED(rc))
    14991504                {
    … …  
    15011506                    RTPrintf("Adding floppy image '%S'...\n", fdaFile);
    15021507                    CHECK_ERROR_BREAK(virtualBox,
    1503                                       OpenMedium(medium, DeviceType_Floppy, AccessMode_ReadWrite, floppyMedium.asOutParam()));
     1508                                      OpenMedium(medium.raw(),
     1509                                                 DeviceType_Floppy,
     1510                                                 AccessMode_ReadWrite,
     1511                                                 floppyMedium.asOutParam()));
    15041512                }
    15051513            }
    … …  
    15341542
    15351543                CHECK_ERROR(storageCtl, COMGETTER(Name)(storageCtlName.asOutParam()));
    1536                 rc = gMachine->GetMediumAttachment(storageCtlName, 0, 0, floppyAttachment.asOutParam());
     1544                rc = gMachine->GetMediumAttachment(storageCtlName.raw(), 0, 0,
     1545                                                   floppyAttachment.asOutParam());
    15371546                if (FAILED(rc))
    1538                     CHECK_ERROR(gMachine, AttachDevice(storageCtlName, 0, 0,
     1547                    CHECK_ERROR(gMachine, AttachDevice(storageCtlName.raw(), 0, 0,
    15391548                                                       DeviceType_Floppy, NULL));
    15401549            }
    … …  
    15421551            {
    15431552                storageCtlName = "Floppy Controller";
    1544                 CHECK_ERROR(gMachine, AddStorageController(storageCtlName,
     1553                CHECK_ERROR(gMachine, AddStorageController(storageCtlName.raw(),
    15451554                                                           StorageBus_Floppy,
    15461555                                                           storageCtl.asOutParam()));
    1547                 CHECK_ERROR(gMachine, AttachDevice(storageCtlName, 0, 0,
     1556                CHECK_ERROR(gMachine, AttachDevice(storageCtlName.raw(), 0, 0,
    15481557                                                   DeviceType_Floppy, NULL));
    15491558            }
    15501559        }
    15511560
    1552         CHECK_ERROR(gMachine, MountMedium(storageCtlName, 0, 0, id, FALSE /* aForce */));
     1561        CHECK_ERROR(gMachine, MountMedium(storageCtlName.raw(), 0, 0, id.raw(),
     1562                                          FALSE /* aForce */));
    15531563    }
    15541564    while (0);
    … …  
    15761586            ComPtr <IHost> host;
    15771587            CHECK_ERROR_BREAK(virtualBox, COMGETTER(Host)(host.asOutParam()));
    1578             rc = host->FindHostDVDDrive(medium,dvdMedium.asOutParam());
     1588            rc = host->FindHostDVDDrive(medium.raw(), dvdMedium.asOutParam());
    15791589            if (FAILED(rc))
    15801590            {
    15811591                /* try to find an existing one */
    1582                 rc = virtualBox->FindMedium(medium, DeviceType_DVD, dvdMedium.asOutParam());
     1592                rc = virtualBox->FindMedium(medium.raw(), DeviceType_DVD,
     1593                                            dvdMedium.asOutParam());
    15831594                if (FAILED(rc))
    15841595                {
    15851596                    /* try to add to the list */
    15861597                    RTPrintf("Adding ISO image '%S'...\n", cdromFile);
    1587                     CHECK_ERROR_BREAK(virtualBox, OpenMedium(medium, DeviceType_DVD, AccessMode_ReadWrite, dvdMedium.asOutParam()));
     1598                    CHECK_ERROR_BREAK(virtualBox, OpenMedium(medium.raw(),
     1599                                                             DeviceType_DVD,
     1600                                                             AccessMode_ReadWrite,
     1601                                                             dvdMedium.asOutParam()));
    15881602                }
    15891603            }
    … …  
    16181632
    16191633                CHECK_ERROR(storageCtl, COMGETTER(Name)(storageCtlName.asOutParam()));
    1620                 gMachine->DetachDevice(storageCtlName, 1, 0);
    1621                 CHECK_ERROR(gMachine, AttachDevice(storageCtlName, 1, 0,
     1634                gMachine->DetachDevice(storageCtlName.raw(), 1, 0);
     1635                CHECK_ERROR(gMachine, AttachDevice(storageCtlName.raw(), 1, 0,
    16221636                                                    DeviceType_DVD, NULL));
    16231637            }
    … …  
    16251639            {
    16261640                storageCtlName = "IDE Controller";
    1627                 CHECK_ERROR(gMachine, AddStorageController(storageCtlName,
     1641                CHECK_ERROR(gMachine, AddStorageController(storageCtlName.raw(),
    16281642                                                           StorageBus_IDE,
    16291643                                                           storageCtl.asOutParam()));
    1630                 CHECK_ERROR(gMachine, AttachDevice(storageCtlName, 1, 0,
     1644                CHECK_ERROR(gMachine, AttachDevice(storageCtlName.raw(), 1, 0,
    16311645                                                   DeviceType_DVD, NULL));
    16321646            }
    16331647        }
    16341648
    1635         CHECK_ERROR(gMachine, MountMedium(storageCtlName, 1, 0, id, FALSE /*aForce */));
     1649        CHECK_ERROR(gMachine, MountMedium(storageCtlName.raw(), 1, 0, id.raw(),
     1650                                          FALSE /*aForce */));
    16361651    }
    16371652    while (0);
    … …  
    17991814        Bstr key = VBOXSDL_SECURELABEL_EXTRADATA;
    18001815        Bstr label;
    1801         gMachine->GetExtraData(key, label.asOutParam());
     1816        gMachine->GetExtraData(key.raw(), label.asOutParam());
    18021817        Utf8Str labelUtf8 = label;
    18031818        /*
    … …  
    18741889            {
    18751890                Bstr bstr = portVRDP;
    1876                 rc = gVrdpServer->COMSETTER(Ports)(bstr);
     1891                rc = gVrdpServer->COMSETTER(Ports)(bstr.raw());
    18771892                if (rc != S_OK)
    18781893                {
    … …  
    26262641                Bstr key = VBOXSDL_SECURELABEL_EXTRADATA;
    26272642                Bstr label;
    2628                 gMachine->GetExtraData(key, label.asOutParam());
     2643                gMachine->GetExtraData(key.raw(), label.asOutParam());
    26292644                Utf8Str labelUtf8 = label;
    26302645                /*
    … …  
    40254040
    40264041    RTStrPrintf(szTitle, sizeof(szTitle), "%s - " VBOX_PRODUCT,
    4027                 name ? Utf8Str(name).c_str() : "<noname>");
     4042                !name.isEmpty() ? Utf8Str(name).c_str() : "<noname>");
    40284043
    40294044    /* which mode are we in? */
    … …  
    46344649            gProgress = NULL;
    46354650            HRESULT rc;
    4636             CHECK_ERROR(gConsole, TakeSnapshot(Bstr(pszSnapshotName), Bstr("Taken by VBoxSDL"),
     4651            CHECK_ERROR(gConsole, TakeSnapshot(Bstr(pszSnapshotName).raw(),
     4652                                               Bstr("Taken by VBoxSDL").raw(),
    46374653                                               gProgress.asOutParam()));
    46384654            if (FAILED(rc))

  • trunk/src/VBox/Main/ApplianceImpl.cpp

    r32448 r32718  
    591591    int i = 1;
    592592    /* @todo: Maybe too cost-intensive; try to find a lighter way */
    593     while (mVirtualBox->FindMachine(Bstr(tmpName), &machine) != VBOX_E_OBJECT_NOT_FOUND)
     593    while (mVirtualBox->FindMachine(Bstr(tmpName).raw(), &machine) != VBOX_E_OBJECT_NOT_FOUND)
    594594    {
    595595        RTStrFree(tmpName);
    … …  
    612612    /* @todo: Maybe too cost-intensive; try to find a lighter way */
    613613    while (    RTPathExists(tmpName)
    614             || mVirtualBox->FindMedium(Bstr(tmpName), DeviceType_HardDisk, &harddisk) != VBOX_E_OBJECT_NOT_FOUND
     614            || mVirtualBox->FindMedium(Bstr(tmpName).raw(), DeviceType_HardDisk, &harddisk) != VBOX_E_OBJECT_NOT_FOUND
    615615          )
    616616    {
    … …  
    694694                rc = pProgressAsync->COMGETTER(OperationWeight(&currentWeight));
    695695                if (FAILED(rc)) throw rc;
    696                 rc = pProgressThis->SetNextOperation(bstr, currentWeight);
     696                rc = pProgressThis->SetNextOperation(bstr.raw(), currentWeight);
    697697                if (FAILED(rc)) throw rc;
    698698                ++cOp;
    … …  
    903903
    904904    rc = pProgress->init(mVirtualBox, static_cast<IAppliance*>(this),
    905                          bstrDescription,
     905                         bstrDescription.raw(),
    906906                         TRUE /* aCancelable */,
    907907                         cOperations, // ULONG cOperations,
    908908                         ulTotalOperationsWeight, // ULONG ulTotalOperationsWeight,
    909                          bstrDescription, // CBSTR bstrFirstOperationDescription,
     909                         bstrDescription.raw(), // CBSTR bstrFirstOperationDescription,
    910910                         m->ulWeightForXmlOperation); // ULONG ulFirstOperationWeight,
    911911    return rc;

  • trunk/src/VBox/Main/ApplianceImplExport.cpp

    r32448 r32718  
    289289            if (FAILED(rc)) throw rc;
    290290
    291             rc = GetStorageControllerByName(controllerName, ctl.asOutParam());
     291            rc = GetStorageControllerByName(controllerName.raw(), ctl.asOutParam());
    292292            if (FAILED(rc)) throw rc;
    293293
    … …  
    15021502
    15031503            Log(("Finding source disk \"%ls\"\n", bstrSrcFilePath.raw()));
    1504             rc = mVirtualBox->FindMedium(bstrSrcFilePath, DeviceType_HardDisk, pSourceDisk.asOutParam());
     1504            rc = mVirtualBox->FindMedium(bstrSrcFilePath.raw(), DeviceType_HardDisk, pSourceDisk.asOutParam());
    15051505            if (FAILED(rc)) throw rc;
    15061506
    … …  
    15231523            // create a new hard disk interface for the destination disk image
    15241524            Log(("Creating target disk \"%s\"\n", strTargetFilePath.c_str()));
    1525             rc = mVirtualBox->CreateHardDisk(bstrSrcFormat,
    1526                                              Bstr(strTargetFilePath),
     1525            rc = mVirtualBox->CreateHardDisk(bstrSrcFormat.raw(),
     1526                                             Bstr(strTargetFilePath).raw(),
    15271527                                             pTargetDisk.asOutParam());
    15281528            if (FAILED(rc)) throw rc;
    … …  
    15371537
    15381538                // advance to the next operation
    1539                 pTask->pProgress->SetNextOperation(BstrFmt(tr("Exporting to disk image '%s'"), RTPathFilename(strTargetFilePath.c_str())),
     1539                pTask->pProgress->SetNextOperation(BstrFmt(tr("Exporting to disk image '%s'"), RTPathFilename(strTargetFilePath.c_str())).raw(),
    15401540                                                   pDiskEntry->ulSizeMB);     // operation's weight, as set up with the IProgress originally);
    15411541
    … …  
    16231623            Utf8Str strMfFile = manifestFileName(pTask->locInfo.strPath.c_str());
    16241624            const char *pcszManifestFileOnly = RTPathFilename(strMfFile.c_str());
    1625             pTask->pProgress->SetNextOperation(BstrFmt(tr("Creating manifest file '%s'"), pcszManifestFileOnly),
     1625            pTask->pProgress->SetNextOperation(BstrFmt(tr("Creating manifest file '%s'"), pcszManifestFileOnly).raw(),
    16261626                                               m->ulWeightForManifestOperation);     // operation's weight, as set up with the IProgress originally);
    16271627
    … …  
    17671767        for (list<Utf8Str>::const_iterator it1 = filesList.begin(); it1 != filesList.end(); ++it1, ++i)
    17681768            paFiles[i] = (*it1).c_str();
    1769         pTask->pProgress->SetNextOperation(BstrFmt(tr("Packing into '%s'"), RTPathFilename(pTask->locInfo.strPath.c_str())), ulWeight);
     1769        pTask->pProgress->SetNextOperation(BstrFmt(tr("Packing into '%s'"), RTPathFilename(pTask->locInfo.strPath.c_str())).raw(), ulWeight);
    17701770        /* Create the tar file out of our file list. */
    17711771        vrc = RTTarCreate(pTask->locInfo.strPath.c_str(), paFiles, filesList.size(), pTask->updateProgress, &pTask);
    … …  
    19301930            char *pszFilename = RTPathFilename(s.first.c_str());
    19311931            /* Advance to the next operation */
    1932             pTask->pProgress->SetNextOperation(BstrFmt(tr("Uploading file '%s'"), pszFilename), s.second);
     1932            pTask->pProgress->SetNextOperation(BstrFmt(tr("Uploading file '%s'"), pszFilename).raw(), s.second);
    19331933            vrc = RTS3PutKey(hS3, bucket.c_str(), pszFilename, s.first.c_str());
    19341934            if (RT_FAILURE(vrc))

  • trunk/src/VBox/Main/ApplianceImplImport.cpp

    r32571 r32718  
    235235            /* Now that we know the OS type, get our internal defaults based on that. */
    236236            ComPtr<IGuestOSType> pGuestOSType;
    237             rc = mVirtualBox->GetGuestOSType(Bstr(strOsTypeVBox), pGuestOSType.asOutParam());
     237            rc = mVirtualBox->GetGuestOSType(Bstr(strOsTypeVBox).raw(), pGuestOSType.asOutParam());
    238238            if (FAILED(rc)) throw rc;
    239239
    … …  
    625625        /* 1 operation only */
    626626        rc = aProgress->init(mVirtualBox, static_cast<IAppliance*>(this),
    627                              bstrDesc,
     627                             bstrDesc.raw(),
    628628                             TRUE /* aCancelable */);
    629629    else
    630630        /* 4/5 is downloading, 1/5 is reading */
    631631        rc = aProgress->init(mVirtualBox, static_cast<IAppliance*>(this),
    632                              bstrDesc,
     632                             bstrDesc.raw(),
    633633                             TRUE /* aCancelable */,
    634634                             2, // ULONG cOperations,
    635635                             5, // ULONG ulTotalOperationsWeight,
    636636                             BstrFmt(tr("Download appliance '%s'"),
    637                                      aLocInfo.strPath.c_str()), // CBSTR bstrFirstOperationDescription,
     637                                     aLocInfo.strPath.c_str()).raw(), // CBSTR bstrFirstOperationDescription,
    638638                             4); // ULONG ulFirstOperationWeight,
    639639    if (FAILED(rc)) throw rc;
    … …  
    859859        hS3 = NIL_RTS3;
    860860
    861         pTask->pProgress->SetNextOperation(Bstr(tr("Reading")), 1);
     861        pTask->pProgress->SetNextOperation(Bstr(tr("Reading")).raw(), 1);
    862862
    863863        /* Prepare the temporary reading of the OVF */
    … …  
    10831083    {
    10841084        const char *pcszManifestFileOnly = RTPathFilename(strManifestFile.c_str());
    1085         pProgress->SetNextOperation(BstrFmt(tr("Verifying manifest file '%s'"), pcszManifestFileOnly),
     1085        pProgress->SetNextOperation(BstrFmt(tr("Verifying manifest file '%s'"), pcszManifestFileOnly).raw(),
    10861086                                    m->ulWeightForManifestOperation);     // operation's weight, as set up with the IProgress originally
    10871087
    … …  
    13291329            Bstr bstrGuid = guid.toUtf16();
    13301330            ComPtr<IMachine> failedMachine;
    1331             HRESULT rc2 = mVirtualBox->GetMachine(bstrGuid, failedMachine.asOutParam());
     1331            HRESULT rc2 = mVirtualBox->GetMachine(bstrGuid.raw(), failedMachine.asOutParam());
    13321332            if (SUCCEEDED(rc2))
    13331333            {
    … …  
    14281428            paFiles[i] = RTPathFilename((*it1).first.c_str());
    14291429        if (!pTask->pProgress.isNull())
    1430             pTask->pProgress->SetNextOperation(BstrFmt(tr("Unpacking file '%s'"), RTPathFilename(pTask->locInfo.strPath.c_str())), ulWeight);
     1430            pTask->pProgress->SetNextOperation(BstrFmt(tr("Unpacking file '%s'"), RTPathFilename(pTask->locInfo.strPath.c_str())).raw(), ulWeight);
    14311431        vrc = RTTarExtractFiles(pTask->locInfo.strPath.c_str(), pszTmpDir, paFiles, filesList.size(), pTask->updateProgress, &pTask);
    14321432        if (RT_FAILURE(vrc))
    … …  
    15511551                srcFormat = L"VMDK";
    15521552            // create an empty hard disk
    1553             rc = mVirtualBox->CreateHardDisk(srcFormat,
    1554                                              Bstr(strTargetPath),
     1553            rc = mVirtualBox->CreateHardDisk(srcFormat.raw(),
     1554                                             Bstr(strTargetPath).raw(),
    15551555                                             pTargetHD.asOutParam());
    15561556            if (FAILED(rc)) throw rc;
    … …  
    15611561
    15621562            // advance to the next operation
    1563             stack.pProgress->SetNextOperation(BstrFmt(tr("Creating disk image '%s'"), strTargetPath.c_str()),
     1563            stack.pProgress->SetNextOperation(BstrFmt(tr("Creating disk image '%s'"), strTargetPath.c_str()).raw(),
    15641564                                              di.ulSuggestedSizeMB);     // operation's weight, as set up with the IProgress originally
    15651565        }
    … …  
    15791579
    15801580            // First open the existing disk image
    1581             rc = mVirtualBox->OpenMedium(Bstr(strSrcFilePath),
     1581            rc = mVirtualBox->OpenMedium(Bstr(strSrcFilePath).raw(),
    15821582                                         DeviceType_HardDisk,
    15831583                                         AccessMode_ReadOnly,
    … …  
    15911591            if (FAILED(rc)) throw rc;
    15921592            /* Create a new hard disk interface for the destination disk image */
    1593             rc = mVirtualBox->CreateHardDisk(srcFormat,
    1594                                              Bstr(strTargetPath),
     1593            rc = mVirtualBox->CreateHardDisk(srcFormat.raw(),
     1594                                             Bstr(strTargetPath).raw(),
    15951595                                             pTargetHD.asOutParam());
    15961596            if (FAILED(rc)) throw rc;
    … …  
    16001600
    16011601            /* Advance to the next operation */
    1602             stack.pProgress->SetNextOperation(BstrFmt(tr("Importing virtual disk image '%s'"), RTPathFilename(strSrcFilePath.c_str())),
     1602            stack.pProgress->SetNextOperation(BstrFmt(tr("Importing virtual disk image '%s'"), RTPathFilename(strSrcFilePath.c_str())).raw(),
    16031603                                              di.ulSuggestedSizeMB);     // operation's weight, as set up with the IProgress originally);
    16041604        }
    … …  
    16481648    // can use recommended defaults for the new machine where OVF doesen't provice any
    16491649    ComPtr<IGuestOSType> osType;
    1650     rc = mVirtualBox->GetGuestOSType(Bstr(stack.strOsTypeVBox), osType.asOutParam());
     1650    rc = mVirtualBox->GetGuestOSType(Bstr(stack.strOsTypeVBox).raw(), osType.asOutParam());
    16511651    if (FAILED(rc)) throw rc;
    16521652
    16531653    /* Create the machine */
    1654     rc = mVirtualBox->CreateMachine(Bstr(stack.strNameVBox),
    1655                                     Bstr(stack.strOsTypeVBox),
     1654    rc = mVirtualBox->CreateMachine(Bstr(stack.strNameVBox).raw(),
     1655                                    Bstr(stack.strOsTypeVBox).raw(),
    16561656                                    NULL,
    16571657                                    NULL,
    … …  
    16631663    if (!stack.strDescription.isEmpty())
    16641664    {
    1665         rc = pNewMachine->COMSETTER(Description)(Bstr(stack.strDescription));
     1665        rc = pNewMachine->COMSETTER(Description)(Bstr(stack.strDescription).raw());
    16661666        if (FAILED(rc)) throw rc;
    16671667    }
    … …  
    17991799                        if (FAILED(rc)) throw rc;
    18001800                        /* Set the interface name to attach to */
    1801                         pNetworkAdapter->COMSETTER(HostInterface)(name);
     1801                        pNetworkAdapter->COMSETTER(HostInterface)(name.raw());
    18021802                        if (FAILED(rc)) throw rc;
    18031803                        break;
    … …  
    18321832                        if (FAILED(rc)) throw rc;
    18331833                        /* Set the interface name to attach to */
    1834                         pNetworkAdapter->COMSETTER(HostInterface)(name);
     1834                        pNetworkAdapter->COMSETTER(HostInterface)(name.raw());
    18351835                        if (FAILED(rc)) throw rc;
    18361836                        break;
    … …  
    18531853        // one or two IDE controllers present in OVF: add one VirtualBox controller
    18541854        ComPtr<IStorageController> pController;
    1855         rc = pNewMachine->AddStorageController(Bstr("IDE Controller"), StorageBus_IDE, pController.asOutParam());
     1855        rc = pNewMachine->AddStorageController(Bstr("IDE Controller").raw(), StorageBus_IDE, pController.asOutParam());
    18561856        if (FAILED(rc)) throw rc;
    18571857
    … …  
    18811881        if (hdcVBox == "AHCI")
    18821882        {
    1883             rc = pNewMachine->AddStorageController(Bstr("SATA Controller"), StorageBus_SATA, pController.asOutParam());
     1883            rc = pNewMachine->AddStorageController(Bstr("SATA Controller").raw(), StorageBus_SATA, pController.asOutParam());
    18841884            if (FAILED(rc)) throw rc;
    18851885        }
    … …  
    19181918                           hdcVBox.c_str());
    19191919
    1920         rc = pNewMachine->AddStorageController(bstrName, busType, pController.asOutParam());
     1920        rc = pNewMachine->AddStorageController(bstrName.raw(), busType, pController.asOutParam());
    19211921        if (FAILED(rc)) throw rc;
    19221922        rc = pController->COMSETTER(ControllerType)(controllerType);
    … …  
    19321932    {
    19331933        ComPtr<IStorageController> pController;
    1934         rc = pNewMachine->AddStorageController(Bstr(L"SAS Controller"), StorageBus_SAS, pController.asOutParam());
     1934        rc = pNewMachine->AddStorageController(Bstr(L"SAS Controller").raw(), StorageBus_SAS, pController.asOutParam());
    19351935        if (FAILED(rc)) throw rc;
    19361936        rc = pController->COMSETTER(ControllerType)(StorageControllerType_LsiLogicSas);
    … …  
    19771977            {
    19781978                ComPtr<IStorageController> pController;
    1979                 rc = sMachine->AddStorageController(Bstr("Floppy Controller"), StorageBus_Floppy, pController.asOutParam());
     1979                rc = sMachine->AddStorageController(Bstr("Floppy Controller").raw(), StorageBus_Floppy, pController.asOutParam());
    19801980                if (FAILED(rc)) throw rc;
    19811981
    … …  
    19931993                Log(("Attaching floppy\n"));
    19941994
    1995                 rc = sMachine->AttachDevice(mhda.controllerType,
     1995                rc = sMachine->AttachDevice(mhda.controllerType.raw(),
    19961996                                            mhda.lControllerPort,
    19971997                                            mhda.lDevice,
    … …  
    20412041                Log(("Attaching CD-ROM to port %d on device %d\n", mhda.lControllerPort, mhda.lDevice));
    20422042
    2043                 rc = sMachine->AttachDevice(mhda.controllerType,
     2043                rc = sMachine->AttachDevice(mhda.controllerType.raw(),
    20442044                                            mhda.lControllerPort,
    20452045                                            mhda.lDevice,
    … …  
    21302130                Log(("Attaching disk %s to port %d on device %d\n", vsdeHD->strVboxCurrent.c_str(), mhda.lControllerPort, mhda.lDevice));
    21312131
    2132                 rc = sMachine->AttachDevice(mhda.controllerType,    // wstring name
     2132                rc = sMachine->AttachDevice(mhda.controllerType.raw(),    // wstring name
    21332133                                            mhda.lControllerPort,          // long controllerPort
    21342134                                            mhda.lDevice,           // long device
    … …  
    24392439            /* Advance to the next operation */
    24402440            if (!pTask->pProgress.isNull())
    2441                 pTask->pProgress->SetNextOperation(BstrFmt(tr("Downloading file '%s'"), pszFilename), s.second);
     2441                pTask->pProgress->SetNextOperation(BstrFmt(tr("Downloading file '%s'"), pszFilename).raw(), s.second);
    24422442
    24432443            vrc = RTS3GetKey(hS3, bucket.c_str(), pszFilename, strSrcFile.c_str());
    … …  
    24692469        char *pszFilename = RTPathFilename(strManifestFile.c_str());
    24702470        if (!pTask->pProgress.isNull())
    2471             pTask->pProgress->SetNextOperation(BstrFmt(tr("Downloading file '%s'"), pszFilename), 1);
     2471            pTask->pProgress->SetNextOperation(BstrFmt(tr("Downloading file '%s'"), pszFilename).raw(), 1);
    24722472
    24732473        /* Try to download it. If the error is VERR_S3_NOT_FOUND, it isn't fatal. */
    … …  
    24962496        hS3 = NIL_RTS3;
    24972497
    2498         pTask->pProgress->SetNextOperation(BstrFmt(tr("Importing appliance")), m->ulWeightForXmlOperation);
     2498        pTask->pProgress->SetNextOperation(BstrFmt(tr("Importing appliance")).raw(), m->ulWeightForXmlOperation);
    24992499
    25002500        ComObjPtr<Progress> progress;

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

    r32403 r32718  
    611611{
    612612    Bstr value;
    613     HRESULT hrc = mMachine->GetExtraData(Bstr("VBoxInternal2/EnableGuestPropertiesVRDP"), value.asOutParam());
     613    HRESULT hrc = mMachine->GetExtraData(Bstr("VBoxInternal2/EnableGuestPropertiesVRDP").raw(),
     614                                         value.asOutParam());
    614615    if (hrc == S_OK)
    615616    {
    … …  
    631632    int rc;
    632633    char *pszPropertyName;
     634    Bstr bstrReadOnlyGuest(L"RDONLYGUEST");
    633635
    634636    rc = RTStrAPrintf(&pszPropertyName, "/VirtualBox/HostInfo/VRDP/Client/%u/Name", u32ClientId);
    … …  
    638640        mRemoteDisplayInfo->COMGETTER(ClientName)(clientName.asOutParam());
    639641
    640         mMachine->SetGuestProperty(Bstr(pszPropertyName), clientName, Bstr("RDONLYGUEST"));
     642        mMachine->SetGuestProperty(Bstr(pszPropertyName).raw(),
     643                                   clientName.raw(),
     644                                   bstrReadOnlyGuest.raw());
    641645        RTStrFree(pszPropertyName);
    642646    }
    … …  
    645649    if (RT_SUCCESS(rc))
    646650    {
    647         mMachine->SetGuestProperty(Bstr(pszPropertyName), Bstr(pszUser), Bstr("RDONLYGUEST"));
     651        mMachine->SetGuestProperty(Bstr(pszPropertyName).raw(),
     652                                   Bstr(pszUser).raw(),
     653                                   bstrReadOnlyGuest.raw());
    648654        RTStrFree(pszPropertyName);
    649655    }
    … …  
    652658    if (RT_SUCCESS(rc))
    653659    {
    654         mMachine->SetGuestProperty(Bstr(pszPropertyName), Bstr(pszDomain), Bstr("RDONLYGUEST"));
     660        mMachine->SetGuestProperty(Bstr(pszPropertyName).raw(),
     661                                   Bstr(pszDomain).raw(),
     662                                   bstrReadOnlyGuest.raw());
    655663        RTStrFree(pszPropertyName);
    656664    }
    … …  
    660668    if (RT_SUCCESS(rc))
    661669    {
    662         mMachine->SetGuestProperty(Bstr("/VirtualBox/HostInfo/VRDP/LastConnectedClient"), Bstr(pszClientId), Bstr("RDONLYGUEST"));
     670        mMachine->SetGuestProperty(Bstr("/VirtualBox/HostInfo/VRDP/LastConnectedClient").raw(),
     671                                   Bstr(pszClientId).raw(),
     672                                   bstrReadOnlyGuest.raw());
    663673        RTStrFree(pszClientId);
    664674    }
    … …  
    680690    if (RT_SUCCESS(rc))
    681691    {
    682         mMachine->SetGuestProperty(Bstr(pszPropertyName), Bstr(""), bstrReadOnlyGuest);
     692        mMachine->SetGuestProperty(Bstr(pszPropertyName).raw(), Bstr("").raw(),
     693                                   bstrReadOnlyGuest.raw());
    683694        RTStrFree(pszPropertyName);
    684695    }
    … …  
    687698    if (RT_SUCCESS(rc))
    688699    {
    689         mMachine->SetGuestProperty(Bstr(pszPropertyName), Bstr(""), bstrReadOnlyGuest);
     700        mMachine->SetGuestProperty(Bstr(pszPropertyName).raw(), Bstr("").raw(),
     701                                   bstrReadOnlyGuest.raw());
    690702        RTStrFree(pszPropertyName);
    691703    }
    … …  
    694706    if (RT_SUCCESS(rc))
    695707    {
    696         mMachine->SetGuestProperty(Bstr(pszPropertyName), Bstr(""), bstrReadOnlyGuest);
     708        mMachine->SetGuestProperty(Bstr(pszPropertyName).raw(), Bstr("").raw(),
     709                                   bstrReadOnlyGuest.raw());
    697710        RTStrFree(pszPropertyName);
    698711    }
    … …  
    702715    if (RT_SUCCESS(rc))
    703716    {
    704         mMachine->SetGuestProperty(Bstr("/VirtualBox/HostInfo/VRDP/LastDisconnectedClient"), Bstr(pszClientId), bstrReadOnlyGuest);
     717        mMachine->SetGuestProperty(Bstr("/VirtualBox/HostInfo/VRDP/LastDisconnectedClient").raw(),
     718                                   Bstr(pszClientId).raw(),
     719                                   bstrReadOnlyGuest.raw());
    705720        RTStrFree(pszClientId);
    706721    }
    … …  
    908923
    909924    Bstr value;
    910     hrc = mMachine->GetExtraData(Bstr("VRDP/ProvideGuestCredentials"), value.asOutParam());
     925    hrc = mMachine->GetExtraData(Bstr("VRDP/ProvideGuestCredentials").raw(),
     926                                 value.asOutParam());
    911927    if (SUCCEEDED(hrc) && value == "1")
    912928    {
    … …  
    916932        Bstr flags;
    917933
    918         hrc = getGuestProperty(Bstr("/VirtualBox/GuestInfo/OS/NoLoggedInUsers"),
     934        hrc = getGuestProperty(Bstr("/VirtualBox/GuestInfo/OS/NoLoggedInUsers").raw(),
    919935                               noLoggedInUsersValue.asOutParam(), &ul64Timestamp, flags.asOutParam());
    920936
    … …  
    12961312        ComObjPtr<SharedFolder> sharedFolder;
    12971313        sharedFolder.createObject();
    1298         HRESULT rc = sharedFolder->init(this, name, hostPath, writable, autoMount);
     1314        HRESULT rc = sharedFolder->init(this, name.raw(), hostPath.raw(),
     1315                                        writable, autoMount);
    12991316        AssertComRCReturn(rc, VERR_INTERNAL_ERROR);
    13001317
    … …  
    13321349    Bstr flags(pCBData->pcszFlags);
    13331350    ComObjPtr<Console> ptrConsole = reinterpret_cast<Console *>(pvExtension);
    1334     HRESULT hrc = ptrConsole->mControl->PushGuestProperty(name,
    1335                                                           value,
     1351    HRESULT hrc = ptrConsole->mControl->PushGuestProperty(name.raw(),
     1352                                                          value.raw(),
    13361353                                                          pCBData->u64Timestamp,
    1337                                                           flags);
     1354                                                          flags.raw());
    13381355    if (SUCCEEDED(hrc))
    13391356        rc = VINF_SUCCESS;
    … …  
    17171734    progress.createObject();
    17181735    progress->init(static_cast<IConsole *>(this),
    1719                    Bstr(tr("Stopping virtual machine")),
     1736                   Bstr(tr("Stopping virtual machine")).raw(),
    17201737                   FALSE /* aCancelable */);
    17211738
    … …  
    22972314    progress.createObject();
    22982315    progress->init(static_cast<IConsole *>(this),
    2299                    Bstr(tr("Saving the execution state of the virtual machine")),
     2316                   Bstr(tr("Saving the execution state of the virtual machine")).raw(),
    23002317                   FALSE /* aCancelable */);
    23012318
    … …  
    28972914    pProgress.createObject();
    28982915    rc = pProgress->init(static_cast<IConsole*>(this),
    2899                          Bstr(tr("Taking a snapshot of the virtual machine")),
     2916                         Bstr(tr("Taking a snapshot of the virtual machine")).raw(),
    29002917                         mMachineState == MachineState_Running /* aCancelable */,
    29012918                         cOperations,
    29022919                         ulTotalOperationsWeight,
    2903                          Bstr(tr("Setting up snapshot operation")),      // first sub-op description
     2920                         Bstr(tr("Setting up snapshot operation")).raw(),      // first sub-op description
    29042921                         1);        // ulFirstOperationWeight
    29052922
    … …  
    52175234        rc = mMachine->COMGETTER(StateFilePath)(savedStateFile.asOutParam());
    52185235        if (FAILED(rc)) return rc;
    5219         ComAssertRet(!!savedStateFile, E_FAIL);
     5236        ComAssertRet(!savedStateFile.isEmpty(), E_FAIL);
    52205237        int vrc = SSMR3ValidateFile(Utf8Str(savedStateFile).c_str(), false /* fChecksumIt */);
    52215238        if (RT_FAILURE(vrc))
    … …  
    52585275        ||  (!fTeleporterEnabled && !fFaultToleranceSyncEnabled))
    52595276        rc = powerupProgress->init(static_cast<IConsole *>(this),
    5260                                    progressDesc,
     5277                                   progressDesc.raw(),
    52615278                                   FALSE /* aCancelable */);
    52625279    else
    52635280    if (fTeleporterEnabled)
    52645281        rc = powerupProgress->init(static_cast<IConsole *>(this),
    5265                                    progressDesc,
     5282                                   progressDesc.raw(),
    52665283                                   TRUE /* aCancelable */,
    52675284                                   3    /* cOperations */,
    52685285                                   10   /* ulTotalOperationsWeight */,
    5269                                    Bstr(tr("Teleporting virtual machine")),
     5286                                   Bstr(tr("Teleporting virtual machine")).raw(),
    52705287                                   1    /* ulFirstOperationWeight */,
    52715288                                   NULL);
    … …  
    52735290    if (fFaultToleranceSyncEnabled)
    52745291        rc = powerupProgress->init(static_cast<IConsole *>(this),
    5275                                    progressDesc,
     5292                                   progressDesc.raw(),
    52765293                                   TRUE /* aCancelable */,
    52775294                                   3    /* cOperations */,
    52785295                                   10   /* ulTotalOperationsWeight */,
    5279                                    Bstr(tr("Fault Tolerance syncing of remote virtual machine")),
     5296                                   Bstr(tr("Fault Tolerance syncing of remote virtual machine")).raw(),
    52805297                                   1    /* ulFirstOperationWeight */,
    52815298                                   NULL);
    … …  
    54495466            progresses.push_back(ComPtr<IProgress> (powerupProgress));
    54505467            rc = progress->init(static_cast<IConsole *>(this),
    5451                                 progressDesc, progresses.begin(),
     5468                                progressDesc.raw(), progresses.begin(),
    54525469                                progresses.end());
    54535470            AssertComRCReturnRC(rc);
    … …  
    59435960                            mGlobalSharedFolders.find(name) !=
    59445961                                mGlobalSharedFolders.end())
    5945                             rc = removeSharedFolder(name);
     5962                            rc = removeSharedFolder(name.raw());
    59465963                        /* create the new machine folder */
    5947                         rc = createSharedFolder(name, SharedFolderData(hostPath, writable, autoMount));
     5964                        rc = createSharedFolder(name.raw(),
     5965                                                SharedFolderData(hostPath,
     5966                                                                 writable,
     5967                                                                 autoMount));
    59485968                    }
    59495969                }
    … …  
    59705990                {
    59715991                    /* remove the outdated machine folder */
    5972                     rc = removeSharedFolder(it->first);
     5992                    rc = removeSharedFolder(it->first.raw());
    59735993                    /* create the global folder if there is any */
    59745994                    SharedFolderDataMap::const_iterator git =
    59755995                        mGlobalSharedFolders.find(it->first);
    59765996                    if (git != mGlobalSharedFolders.end())
    5977                         rc = createSharedFolder(git->first, git->second);
     5997                        rc = createSharedFolder(git->first.raw(), git->second);
    59785998                }
    59795999            }
    … …  
    60276047{
    60286048    ComAssertRet(aName && *aName, E_FAIL);
    6029     ComAssertRet(aData.mHostPath, E_FAIL);
     6049    ComAssertRet(!aData.mHostPath.isEmpty(), E_FAIL);
    60306050
    60316051    /* sanity checks */
    … …  
    60396059    Log(("Adding shared folder '%ls' -> '%ls'\n", aName, aData.mHostPath.raw()));
    60406060
    6041     cbString = (RTUtf16Len(aData.mHostPath) + 1) * sizeof(RTUTF16);
     6061    cbString = (RTUtf16Len(aData.mHostPath.raw()) + 1) * sizeof(RTUTF16);
    60426062    if (cbString >= UINT16_MAX)
    60436063        return setError(E_INVALIDARG, tr("The name is too long"));
    60446064    pFolderName = (SHFLSTRING *) RTMemAllocZ(sizeof(SHFLSTRING) + cbString);
    60456065    Assert(pFolderName);
    6046     memcpy(pFolderName->String.ucs2, aData.mHostPath, cbString);
     6066    memcpy(pFolderName->String.ucs2, aData.mHostPath.raw(), cbString);
    60476067
    60486068    pFolderName->u16Size   = (uint16_t)cbString;
    … …  
    70527072             fFatal, pszErrorId, message.c_str()));
    70537073
    7054     that->onRuntimeError(BOOL(fFatal), Bstr(pszErrorId), Bstr(message));
     7074    that->onRuntimeError(BOOL(fFatal), Bstr(pszErrorId).raw(),
     7075                         Bstr(message).raw());
    70557076
    70567077    LogFlowFuncLeave();
    … …  
    72717292            Bstr uuid;
    72727293            device->COMGETTER(Id)(uuid.asOutParam());
    7273             onUSBDeviceDetach(uuid, NULL);
     7294            onUSBDeviceDetach(uuid.raw(), NULL);
    72747295        }
    72757296
    … …  
    74857506                         ++ it)
    74867507                    {
    7487                         rc = console->createSharedFolder((*it).first, (*it).second);
     7508                        rc = console->createSharedFolder((*it).first.raw(),
     7509                                                         (*it).second);
    74887510                        if (FAILED(rc)) break;
    74897511                    }
    … …  
    78437865         */
    78447866        rc = that->mControl->BeginTakingSnapshot(that,
    7845                                                  pTask->bstrName,
    7846                                                  pTask->bstrDescription,
     7867                                                 pTask->bstrName.raw(),
     7868                                                 pTask->bstrDescription.raw(),
    78477869                                                 pTask->mProgress,
    78487870                                                 pTask->fTakingSnapshotOnline,
    … …  
    78737895            Utf8Str strSavedStateFile(pTask->bstrSavedStateFile);
    78747896
    7875             pTask->mProgress->SetNextOperation(Bstr(tr("Saving the machine state")),
     7897            pTask->mProgress->SetNextOperation(Bstr(tr("Saving the machine state")).raw(),
    78767898                                               pTask->ulMemSize);       // operation weight, same as computed when setting up progress object
    78777899            pTask->mProgress->setCancelCallback(takesnapshotProgressCancelCallback, that->mpVM);
    … …  
    78997921            LogFlowFunc(("Reattaching new differencing hard disks...\n"));
    79007922
    7901             pTask->mProgress->SetNextOperation(Bstr(tr("Reconfiguring medium attachments")),
     7923            pTask->mProgress->SetNextOperation(Bstr(tr("Reconfiguring medium attachments")).raw(),
    79027924                                               1);       // operation weight, same as computed when setting up progress object
    79037925
    … …  
    79277949                    throw rc;
    79287950
    7929                 rc = that->mMachine->GetStorageControllerByName(controllerName, controller.asOutParam());
     7951                rc = that->mMachine->GetStorageControllerByName(controllerName.raw(),
     7952                                                                controller.asOutParam());
    79307953                if (FAILED(rc))
    79317954                    throw rc;

  • trunk/src/VBox/Main/ConsoleImpl2.cpp

    r32672 r32718  
    231231    Bstr aFilePath, empty;
    232232
    233     rc = vbox->CheckFirmwarePresent(aFirmwareType, empty,
     233    rc = vbox->CheckFirmwarePresent(aFirmwareType, empty.raw(),
    234234                                    empty.asOutParam(), aFilePath.asOutParam(), &fPresent);
    235235    if (RT_FAILURE(rc))
    … …  
    251251     * The extra data takes precedence (if non-zero).
    252252     */
    253     HRESULT hrc = pMachine->GetExtraData(Bstr("VBoxInternal2/SmcDeviceKey"), aKey);
     253    HRESULT hrc = pMachine->GetExtraData(Bstr("VBoxInternal2/SmcDeviceKey").raw(),
     254                                         aKey);
    254255    if (FAILED(hrc))
    255256        return Global::vboxStatusCodeFromCOM(hrc);
    … …  
    555556
    556557    ComPtr<IGuestOSType> guestOSType;
    557     hrc = virtualBox->GetGuestOSType(osTypeId, guestOSType.asOutParam());               H();
     558    hrc = virtualBox->GetGuestOSType(osTypeId.raw(), guestOSType.asOutParam());         H();
    558559
    559560    Bstr guestTypeFamilyId;
    … …  
    659660           - With more than one virtual CPU, raw-mode isn't a fallback option. */
    660661        fHwVirtExtForced = fHWVirtExEnabled
    661                         && (   cbRam > (_4G - cbRamHole)
     662                        && (   cbRam + cbRamHole > _4G
    662663                            || cCpus > 1);
    663664# endif
    … …  
    10461047        Bstr logoImagePath;
    10471048        hrc = biosSettings->COMGETTER(LogoImagePath)(logoImagePath.asOutParam());           H();
    1048         InsertConfigString(pCfg,   "LogoFile", Utf8Str(logoImagePath ? logoImagePath : "") );
     1049        InsertConfigString(pCfg,   "LogoFile", Utf8Str(!logoImagePath.isEmpty() ? logoImagePath : "") );
    10491050
    10501051        /*
    … …  
    10681069            char szExtraDataKey[sizeof("CustomVideoModeXX")];
    10691070            RTStrPrintf(szExtraDataKey, sizeof(szExtraDataKey), "CustomVideoMode%u", iMode);
    1070             hrc = pMachine->GetExtraData(Bstr(szExtraDataKey), bstr.asOutParam());          H();
     1071            hrc = pMachine->GetExtraData(Bstr(szExtraDataKey).raw(), bstr.asOutParam());    H();
    10711072            if (bstr.isEmpty())
    10721073                break;
    … …  
    11891190            /* Get boot args */
    11901191            Bstr bootArgs;
    1191             hrc = pMachine->GetExtraData(Bstr("VBoxInternal2/EfiBootArgs"), bootArgs.asOutParam()); H();
     1192            hrc = pMachine->GetExtraData(Bstr("VBoxInternal2/EfiBootArgs").raw(), bootArgs.asOutParam()); H();
    11921193
    11931194            /* Get device props */
    11941195            Bstr deviceProps;
    1195             hrc = pMachine->GetExtraData(Bstr("VBoxInternal2/EfiDeviceProps"), deviceProps.asOutParam()); H();
     1196            hrc = pMachine->GetExtraData(Bstr("VBoxInternal2/EfiDeviceProps").raw(), deviceProps.asOutParam()); H();
    11961197            /* Get GOP mode settings */
    11971198            uint32_t u32GopMode = UINT32_MAX;
    1198             hrc = pMachine->GetExtraData(Bstr("VBoxInternal2/EfiGopMode"), bstr.asOutParam()); H();
     1199            hrc = pMachine->GetExtraData(Bstr("VBoxInternal2/EfiGopMode").raw(), bstr.asOutParam()); H();
    11991200            if (!bstr.isEmpty())
    12001201                u32GopMode = Utf8Str(bstr).toUInt32();
    … …  
    12021203            /* UGA mode settings */
    12031204            uint32_t u32UgaHorisontal = 0;
    1204             hrc = pMachine->GetExtraData(Bstr("VBoxInternal2/EfiUgaHorizontalResolution"), bstr.asOutParam()); H();
     1205            hrc = pMachine->GetExtraData(Bstr("VBoxInternal2/EfiUgaHorizontalResolution").raw(), bstr.asOutParam()); H();
    12051206            if (!bstr.isEmpty())
    12061207                u32UgaHorisontal = Utf8Str(bstr).toUInt32();
    12071208
    12081209            uint32_t u32UgaVertical = 0;
    1209             hrc = pMachine->GetExtraData(Bstr("VBoxInternal2/EfiUgaVerticalResolution"), bstr.asOutParam()); H();
     1210            hrc = pMachine->GetExtraData(Bstr("VBoxInternal2/EfiUgaVerticalResolution").raw(), bstr.asOutParam()); H();
    12101211            if (!bstr.isEmpty())
    12111212                u32UgaVertical = Utf8Str(bstr).toUInt32();
    … …  
    14461447            /* Attach the media to the storage controllers. */
    14471448            com::SafeIfaceArray<IMediumAttachment> atts;
    1448             hrc = pMachine->GetMediumAttachmentsOfController(controllerName,
     1449            hrc = pMachine->GetMediumAttachmentsOfController(controllerName.raw(),
    14491450                                                            ComSafeArrayAsOutParam(atts)); H();
    14501451
    … …  
    14521453            {
    14531454                rc = pConsole->configMediumAttachment(pCtlInst,
    1454                                                     pszCtrlDev,
    1455                                                     ulInstance,
    1456                                                     enmBus,
    1457                                                     fUseHostIOCache,
    1458                                                     false /* fSetupMerge */,
    1459                                                     0 /* uMergeSource */,
    1460                                                     0 /* uMergeTarget */,
    1461                                                     atts[j],
    1462                                                     pConsole->mMachineState,
    1463                                                     NULL /* phrc */,
    1464                                                     false /* fAttachDetach */,
    1465                                                     false /* fForceUnmount */,
    1466                                                     pVM,
    1467                                                     paLedDevType);
     1455                                                      pszCtrlDev,
     1456                                                      ulInstance,
     1457                                                      enmBus,
     1458                                                      fUseHostIOCache,
     1459                                                      false /* fSetupMerge */,
     1460                                                      0 /* uMergeSource */,
     1461                                                      0 /* uMergeTarget */,
     1462                                                      atts[j],
     1463                                                      pConsole->mMachineState,
     1464                                                      NULL /* phrc */,
     1465                                                      false /* fAttachDetach */,
     1466                                                      false /* fForceUnmount */,
     1467                                                      pVM,
     1468                                                      paLedDevType);
    14681469                if (RT_FAILURE(rc))
    14691470                    return rc;
    … …  
    16091610            Bstr macAddr;
    16101611            hrc = networkAdapter->COMGETTER(MACAddress)(macAddr.asOutParam());              H();
    1611             Assert(macAddr);
     1612            Assert(!macAddr.isEmpty());
    16121613            Utf8Str macAddrUtf8 = macAddr;
    16131614            char *macStr = (char*)macAddrUtf8.c_str();
    … …  
    17931794        hrc = pMachine->COMGETTER(HardwareVersion)(hwVersion.asOutParam());                 H();
    17941795        InsertConfigInteger(pCfg, "RamSize",              cbRam);
    1795         if (hwVersion.compare(Bstr("1")) == 0) /* <= 2.0.x */
     1796        if (hwVersion.compare(Bstr("1").raw()) == 0) /* <= 2.0.x */
    17961797            InsertConfigInteger(pCfg, "HeapEnabled", 0);
    17971798        Bstr snapshotFolder;
    … …  
    23862387            if (i2 < cGlobalValues)
    23872388                // this is still one of the global values:
    2388                 hrc = virtualBox->GetExtraData(Bstr(strKey), bstrExtraDataValue.asOutParam());
     2389                hrc = virtualBox->GetExtraData(Bstr(strKey).raw(),
     2390                                               bstrExtraDataValue.asOutParam());
    23892391            else
    2390                 hrc = pMachine->GetExtraData(Bstr(strKey), bstrExtraDataValue.asOutParam());
     2392                hrc = pMachine->GetExtraData(Bstr(strKey).raw(),
     2393                                             bstrExtraDataValue.asOutParam());
    23912394            if (FAILED(hrc))
    23922395                LogRel(("Warning: Cannot get extra data key %s, rc = %Rrc\n", strKey.c_str(), hrc));
    … …  
    38643867                const char *pszHifName = HifNameUtf8.c_str();
    38653868                ComPtr<IHostNetworkInterface> hostInterface;
    3866                 rc = host->FindHostNetworkInterfaceByName(HifName, hostInterface.asOutParam());
     3869                rc = host->FindHostNetworkInterfaceByName(HifName.raw(),
     3870                                                          hostInterface.asOutParam());
    38673871                if (!SUCCEEDED(rc))
    38683872                {
    … …  
    40054009                Bstr tmpAddr, tmpMask;
    40064010
    4007                 hrc = virtualBox->GetExtraData(BstrFmt("HostOnly/%s/IPAddress", pszHifName), tmpAddr.asOutParam());
     4011                hrc = virtualBox->GetExtraData(BstrFmt("HostOnly/%s/IPAddress",
     4012                                                       pszHifName).raw(),
     4013                                               tmpAddr.asOutParam());
    40084014                if (SUCCEEDED(hrc) && !tmpAddr.isEmpty())
    40094015                {
    4010                     hrc = virtualBox->GetExtraData(BstrFmt("HostOnly/%s/IPNetMask", pszHifName), tmpMask.asOutParam());
     4016                    hrc = virtualBox->GetExtraData(BstrFmt("HostOnly/%s/IPNetMask",
     4017                                                           pszHifName).raw(),
     4018                                                   tmpMask.asOutParam());
    40114019                    if (SUCCEEDED(hrc) && !tmpMask.isEmpty())
    4012                         hrc = hostInterface->EnableStaticIpConfig(tmpAddr, tmpMask);
     4020                        hrc = hostInterface->EnableStaticIpConfig(tmpAddr.raw(),
     4021                                                                  tmpMask.raw());
    40134022                    else
    4014                         hrc = hostInterface->EnableStaticIpConfig(tmpAddr,
    4015                                                                 Bstr(VBOXNET_IPV4MASK_DEFAULT));
     4023                        hrc = hostInterface->EnableStaticIpConfig(tmpAddr.raw(),
     4024                                                                  Bstr(VBOXNET_IPV4MASK_DEFAULT).raw());
    40164025                }
    40174026                else
    40184027                {
    40194028                    /* Grab the IP number from the 'vboxnetX' instance number (see netif.h) */
    4020                     hrc = hostInterface->EnableStaticIpConfig(getDefaultIPv4Address(Bstr(pszHifName)),
    4021                                                             Bstr(VBOXNET_IPV4MASK_DEFAULT));
     4029                    hrc = hostInterface->EnableStaticIpConfig(getDefaultIPv4Address(Bstr(pszHifName)).raw(),
     4030                                                              Bstr(VBOXNET_IPV4MASK_DEFAULT).raw());
    40224031                }
    40234032
    40244033                ComAssertComRC(hrc); /** @todo r=bird: Why this isn't fatal? (H()) */
    40254034
    4026                 hrc = virtualBox->GetExtraData(BstrFmt("HostOnly/%s/IPV6Address", pszHifName), tmpAddr.asOutParam());
     4035                hrc = virtualBox->GetExtraData(BstrFmt("HostOnly/%s/IPV6Address",
     4036                                                       pszHifName).raw(),
     4037                                               tmpAddr.asOutParam());
    40274038                if (SUCCEEDED(hrc))
    4028                     hrc = virtualBox->GetExtraData(BstrFmt("HostOnly/%s/IPV6NetMask", pszHifName), tmpMask.asOutParam());
     4039                    hrc = virtualBox->GetExtraData(BstrFmt("HostOnly/%s/IPV6NetMask", pszHifName).raw(),
     4040                                                   tmpMask.asOutParam());
    40294041                if (SUCCEEDED(hrc) && !tmpAddr.isEmpty() && !tmpMask.isEmpty())
    40304042                {
    4031                     hrc = hostInterface->EnableStaticIpConfigV6(tmpAddr, Utf8Str(tmpMask).toUInt32());
     4043                    hrc = hostInterface->EnableStaticIpConfigV6(tmpAddr.raw(),
     4044                                                                Utf8Str(tmpMask).toUInt32());
    40324045                    ComAssertComRC(hrc); /** @todo r=bird: Why this isn't fatal? (H()) */
    40334046                }
    … …  
    40974110                         */
    40984111                        ComPtr<IDHCPServer> dhcpServer;
    4099                         hrc = virtualBox->FindDHCPServerByNetworkName(networkName, dhcpServer.asOutParam());
     4112                        hrc = virtualBox->FindDHCPServerByNetworkName(networkName.raw(),
     4113                                                                      dhcpServer.asOutParam());
    41004114                        if (SUCCEEDED(hrc))
    41014115                        {
    … …  
    41104124
    41114125                            if (fEnabled)
    4112                                 hrc = dhcpServer->Start(networkName, trunkName, trunkType);
     4126                                hrc = dhcpServer->Start(networkName.raw(),
     4127                                                        trunkName.raw(),
     4128                                                        trunkType.raw());
    41134129                        }
    41144130                        else

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

    r31256 r32718  
    956956    HRESULT hrc = ptrProgress.createObject();
    957957    if (FAILED(hrc)) return hrc;
    958     hrc = ptrProgress->init(static_cast<IConsole *>(this), Bstr(tr("Teleporter")), TRUE /*aCancelable*/);
     958    hrc = ptrProgress->init(static_cast<IConsole *>(this),
     959                            Bstr(tr("Teleporter")).raw(),
     960                            TRUE /*aCancelable*/);
    959961    if (FAILED(hrc)) return hrc;
    960962
    … …  
    10931095            {
    10941096                LogRel(("Teleporter: Waiting for incoming VM...\n"));
    1095                 hrc = pProgress->SetNextOperation(Bstr(tr("Waiting for incoming VM")), 1);
     1097                hrc = pProgress->SetNextOperation(Bstr(tr("Waiting for incoming VM")).raw(), 1);
    10961098                if (SUCCEEDED(hrc))
    10971099                {
    … …  
    12821284    {
    12831285        LogRel(("Teleporter: Incoming VM from %RTnaddr!\n", &Addr));
    1284         hrc = pState->mptrProgress->SetNextOperation(BstrFmt(tr("Teleporting VM from %RTnaddr"), &Addr), 8);
     1286        hrc = pState->mptrProgress->SetNextOperation(BstrFmt(tr("Teleporting VM from %RTnaddr"), &Addr).raw(), 8);
    12851287    }
    12861288    else
    12871289    {
    12881290        LogRel(("Teleporter: Incoming VM!\n"));
    1289         hrc = pState->mptrProgress->SetNextOperation(Bstr(tr("Teleporting VM")), 8);
     1291        hrc = pState->mptrProgress->SetNextOperation(Bstr(tr("Teleporting VM")).raw(), 8);
    12901292    }
    12911293    AssertMsg(SUCCEEDED(hrc) || hrc == E_FAIL, ("%Rhrc\n", hrc));

  • trunk/src/VBox/Main/ConsoleVRDPServer.cpp

    r32431 r32718  
    391391    if (m_server)
    392392    {
    393         com::SafeArray <BYTE> aShape(ComSafeArrayInArg (inShape));
     393        com::SafeArray <BYTE> aShape(ComSafeArrayInArg(inShape));
    394394        if (aShape.size() == 0)
    395395        {
    … …  
    665665            com::Utf8Str portRange = bstr;
    666666
    667             size_t cbPortRange = portRange.length () + 1;
     667            size_t cbPortRange = portRange.length() + 1;
    668668
    669669            if (cbPortRange >= 0x10000)
    … …  
    731731
    732732            com::Bstr bstr;
    733             HRESULT hrc = server->mConsole->machine ()->GetExtraData(Bstr("VRDP/SunFlsh"), bstr.asOutParam());
     733            HRESULT hrc = server->mConsole->machine()->GetExtraData(Bstr("VRDP/SunFlsh").raw(),
     734                                                                    bstr.asOutParam());
    734735            if (hrc == S_OK && !bstr.isEmpty())
    735736            {
    … …  
    792793               )
    793794            {
    794                 HRESULT hrc = server->mConsole->machine ()->GetExtraData(com::Bstr(extraData), bstrValue.asOutParam());
     795                HRESULT hrc = server->mConsole->machine()->GetExtraData(com::Bstr(extraData).raw(),
     796                                                                        bstrValue.asOutParam());
    795797                if (hrc == S_OK && !bstrValue.isEmpty())
    796798                {
    … …  
    856858    ConsoleVRDPServer *server = static_cast<ConsoleVRDPServer*>(pvCallback);
    857859
    858     return server->mConsole->VRDPClientLogon (u32ClientId, pszUser, pszPassword, pszDomain);
    859 }
    860 
    861 DECLCALLBACK(void) ConsoleVRDPServer::VRDPCallbackClientConnect (void *pvCallback, uint32_t u32ClientId)
     860    return server->mConsole->VRDPClientLogon(u32ClientId, pszUser, pszPassword, pszDomain);
     861}
     862
     863DECLCALLBACK(void) ConsoleVRDPServer::VRDPCallbackClientConnect(void *pvCallback, uint32_t u32ClientId)
    862864{
    863865    ConsoleVRDPServer *server = static_cast<ConsoleVRDPServer*>(pvCallback);
    864866
    865     server->mConsole->VRDPClientConnect (u32ClientId);
    866 }
    867 
    868 DECLCALLBACK(void) ConsoleVRDPServer::VRDPCallbackClientDisconnect (void *pvCallback, uint32_t u32ClientId, uint32_t fu32Intercepted)
     867    server->mConsole->VRDPClientConnect(u32ClientId);
     868}
     869
     870DECLCALLBACK(void) ConsoleVRDPServer::VRDPCallbackClientDisconnect(void *pvCallback, uint32_t u32ClientId, uint32_t fu32Intercepted)
    869871{
    870872    ConsoleVRDPServer *server = static_cast<ConsoleVRDPServer*>(pvCallback);
    871873
    872     server->mConsole->VRDPClientDisconnect (u32ClientId, fu32Intercepted);
    873 }
    874 
    875 DECLCALLBACK(int)  ConsoleVRDPServer::VRDPCallbackIntercept (void *pvCallback, uint32_t u32ClientId, uint32_t fu32Intercept, void **ppvIntercept)
     874    server->mConsole->VRDPClientDisconnect(u32ClientId, fu32Intercepted);
     875}
     876
     877DECLCALLBACK(int)  ConsoleVRDPServer::VRDPCallbackIntercept(void *pvCallback, uint32_t u32ClientId, uint32_t fu32Intercept, void **ppvIntercept)
    876878{
    877879    ConsoleVRDPServer *server = static_cast<ConsoleVRDPServer*>(pvCallback);
    … …  
    885887        case VRDP_CLIENT_INTERCEPT_AUDIO:
    886888        {
    887             server->mConsole->VRDPInterceptAudio (u32ClientId);
     889            server->mConsole->VRDPInterceptAudio(u32ClientId);
    888890            if (ppvIntercept)
    889891            {
    … …  
    895897        case VRDP_CLIENT_INTERCEPT_USB:
    896898        {
    897             server->mConsole->VRDPInterceptUSB (u32ClientId, ppvIntercept);
     899            server->mConsole->VRDPInterceptUSB(u32ClientId, ppvIntercept);
    898900            rc = VINF_SUCCESS;
    899901        } break;
    … …  
    901903        case VRDP_CLIENT_INTERCEPT_CLIPBOARD:
    902904        {
    903             server->mConsole->VRDPInterceptClipboard (u32ClientId);
     905            server->mConsole->VRDPInterceptClipboard(u32ClientId);
    904906            if (ppvIntercept)
    905907            {
    … …  
    916918}
    917919
    918 DECLCALLBACK(int)  ConsoleVRDPServer::VRDPCallbackUSB (void *pvCallback, void *pvIntercept, uint32_t u32ClientId, uint8_t u8Code, const void *pvRet, uint32_t cbRet)
     920DECLCALLBACK(int)  ConsoleVRDPServer::VRDPCallbackUSB(void *pvCallback, void *pvIntercept, uint32_t u32ClientId, uint8_t u8Code, const void *pvRet, uint32_t cbRet)
    919921{
    920922#ifdef VBOX_WITH_USB
    921     return USBClientResponseCallback (pvIntercept, u32ClientId, u8Code, pvRet, cbRet);
     923    return USBClientResponseCallback(pvIntercept, u32ClientId, u8Code, pvRet, cbRet);
    922924#else
    923925    return VERR_NOT_SUPPORTED;
    … …  
    925927}
    926928
    927 DECLCALLBACK(int)  ConsoleVRDPServer::VRDPCallbackClipboard (void *pvCallback, void *pvIntercept, uint32_t u32ClientId, uint32_t u32Function, uint32_t u32Format, const void *pvData, uint32_t cbData)
    928 {
    929     return ClipboardCallback (pvIntercept, u32ClientId, u32Function, u32Format, pvData, cbData);
    930 }
    931 
    932 DECLCALLBACK(bool) ConsoleVRDPServer::VRDPCallbackFramebufferQuery (void *pvCallback, unsigned uScreenId, VRDPFRAMEBUFFERINFO *pInfo)
     929DECLCALLBACK(int)  ConsoleVRDPServer::VRDPCallbackClipboard(void *pvCallback, void *pvIntercept, uint32_t u32ClientId, uint32_t u32Function, uint32_t u32Format, const void *pvData, uint32_t cbData)
     930{
     931    return ClipboardCallback(pvIntercept, u32ClientId, u32Function, u32Format, pvData, cbData);
     932}
     933
     934DECLCALLBACK(bool) ConsoleVRDPServer::VRDPCallbackFramebufferQuery(void *pvCallback, unsigned uScreenId, VRDPFRAMEBUFFERINFO *pInfo)
    933935{
    934936    ConsoleVRDPServer *server = static_cast<ConsoleVRDPServer*>(pvCallback);
    … …  
    940942    LONG yOrigin = 0;
    941943
    942     server->mConsole->getDisplay ()->GetFramebuffer (uScreenId, &pfb, &xOrigin, &yOrigin);
     944    server->mConsole->getDisplay()->GetFramebuffer(uScreenId, &pfb, &xOrigin, &yOrigin);
    943945
    944946    if (pfb)
    … …  
    948950        /* Query framebuffer parameters. */
    949951        ULONG lineSize = 0;
    950         pfb->COMGETTER(BytesPerLine) (&lineSize);
     952        pfb->COMGETTER(BytesPerLine)(&lineSize);
    951953
    952954        ULONG bitsPerPixel = 0;
    953         pfb->COMGETTER(BitsPerPixel) (&bitsPerPixel);
     955        pfb->COMGETTER(BitsPerPixel)(&bitsPerPixel);
    954956
    955957        BYTE *address = NULL;
    956         pfb->COMGETTER(Address) (&address);
     958        pfb->COMGETTER(Address)(&address);
    957959
    958960        ULONG height = 0;
    959         pfb->COMGETTER(Height) (&height);
     961        pfb->COMGETTER(Height)(&height);
    960962
    961963        ULONG width = 0;
    962         pfb->COMGETTER(Width) (&width);
     964        pfb->COMGETTER(Width)(&width);
    963965
    964966        /* Now fill the information as requested by the caller. */
    … …  
    971973        pInfo->cbLine = lineSize;
    972974
    973         pfb->Unlock ();
     975        pfb->Unlock();
    974976
    975977        fAvailable = true;
    … …  
    978980    if (server->maFramebuffers[uScreenId])
    979981    {
    980         server->maFramebuffers[uScreenId]->Release ();
     982        server->maFramebuffers[uScreenId]->Release();
    981983    }
    982984    server->maFramebuffers[uScreenId] = pfb;
    … …  
    985987}
    986988
    987 DECLCALLBACK(void) ConsoleVRDPServer::VRDPCallbackFramebufferLock (void *pvCallback, unsigned uScreenId)
     989DECLCALLBACK(void) ConsoleVRDPServer::VRDPCallbackFramebufferLock(void *pvCallback, unsigned uScreenId)
    988990{
    989991    ConsoleVRDPServer *server = static_cast<ConsoleVRDPServer*>(pvCallback);
    … …  
    991993    if (server->maFramebuffers[uScreenId])
    992994    {
    993         server->maFramebuffers[uScreenId]->Lock ();
    994     }
    995 }
    996 
    997 DECLCALLBACK(void) ConsoleVRDPServer::VRDPCallbackFramebufferUnlock (void *pvCallback, unsigned uScreenId)
     995        server->maFramebuffers[uScreenId]->Lock();
     996    }
     997}
     998
     999DECLCALLBACK(void) ConsoleVRDPServer::VRDPCallbackFramebufferUnlock(void *pvCallback, unsigned uScreenId)
    9981000{
    9991001    ConsoleVRDPServer *server = static_cast<ConsoleVRDPServer*>(pvCallback);
    … …  
    10011003    if (server->maFramebuffers[uScreenId])
    10021004    {
    1003         server->maFramebuffers[uScreenId]->Unlock ();
    1004     }
    1005 }
    1006 
    1007 static void fixKbdLockStatus (VRDPInputSynch *pInputSynch, IKeyboard *pKeyboard)
     1005        server->maFramebuffers[uScreenId]->Unlock();
     1006    }
     1007}
     1008
     1009static void fixKbdLockStatus(VRDPInputSynch *pInputSynch, IKeyboard *pKeyboard)
    10081010{
    10091011    if (   pInputSynch->cGuestNumLockAdaptions
    … …  
    10231025}
    10241026
    1025 DECLCALLBACK(void) ConsoleVRDPServer::VRDPCallbackInput (void *pvCallback, int type, const void *pvInput, unsigned cbInput)
     1027DECLCALLBACK(void) ConsoleVRDPServer::VRDPCallbackInput(void *pvCallback, int type, const void *pvInput, unsigned cbInput)
    10261028{
    10271029    ConsoleVRDPServer *server = static_cast<ConsoleVRDPServer*>(pvCallback);
    … …  
    10321034        case VRDP_INPUT_SCANCODE:
    10331035        {
    1034             if (cbInput == sizeof (VRDPINPUTSCANCODE))
    1035             {
    1036                 IKeyboard *pKeyboard = pConsole->getKeyboard ();
     1036            if (cbInput == sizeof(VRDPINPUTSCANCODE))
     1037            {
     1038                IKeyboard *pKeyboard = pConsole->getKeyboard();
    10371039
    10381040                const VRDPINPUTSCANCODE *pInputScancode = (VRDPINPUTSCANCODE *)pvInput;
    … …  
    10541056                {
    10551057                    /* Key pressed. */
    1056                     fixKbdLockStatus (&server->m_InputSynch, pKeyboard);
     1058                    fixKbdLockStatus(&server->m_InputSynch, pKeyboard);
    10571059                }
    10581060
    … …  
    10631065        case VRDP_INPUT_POINT:
    10641066        {
    1065             if (cbInput == sizeof (VRDPINPUTPOINT))
     1067            if (cbInput == sizeof(VRDPINPUTPOINT))
    10661068            {
    10671069                const VRDPINPUTPOINT *pInputPoint = (VRDPINPUTPOINT *)pvInput;
    … …  
    10951097                if (server->m_fGuestWantsAbsolute)
    10961098                {
    1097                     pConsole->getMouse()->PutMouseEventAbsolute (pInputPoint->x + 1, pInputPoint->y + 1, iWheel, 0 /* Horizontal wheel */, mouseButtons);
     1099                    pConsole->getMouse()->PutMouseEventAbsolute(pInputPoint->x + 1, pInputPoint->y + 1, iWheel, 0 /* Horizontal wheel */, mouseButtons);
    10981100                } else
    10991101                {
    1100                     pConsole->getMouse()->PutMouseEvent (pInputPoint->x - server->m_mousex,
     1102                    pConsole->getMouse()->PutMouseEvent(pInputPoint->x - server->m_mousex,
    11011103                                                         pInputPoint->y - server->m_mousey,
    11021104                                                         iWheel, 0 /* Horizontal wheel */, mouseButtons);
    … …  
    11091111        case VRDP_INPUT_CAD:
    11101112        {
    1111             pConsole->getKeyboard ()->PutCAD();
     1113            pConsole->getKeyboard()->PutCAD();
    11121114        } break;
    11131115
    … …  
    11191121        case VRDP_INPUT_SYNCH:
    11201122        {
    1121             if (cbInput == sizeof (VRDPINPUTSYNCH))
    1122             {
    1123                 IKeyboard *pKeyboard = pConsole->getKeyboard ();
     1123            if (cbInput == sizeof(VRDPINPUTSYNCH))
     1124            {
     1125                IKeyboard *pKeyboard = pConsole->getKeyboard();
    11241126
    11251127                const VRDPINPUTSYNCH *pInputSynch = (VRDPINPUTSYNCH *)pvInput;
    … …  
    11431145                }
    11441146
    1145                 fixKbdLockStatus (&server->m_InputSynch, pKeyboard);
     1147                fixKbdLockStatus(&server->m_InputSynch, pKeyboard);
    11461148            }
    11471149        } break;
    … …  
    11521154}
    11531155
    1154 DECLCALLBACK(void) ConsoleVRDPServer::VRDPCallbackVideoModeHint (void *pvCallback, unsigned cWidth, unsigned cHeight, unsigned cBitsPerPixel, unsigned uScreenId)
     1156DECLCALLBACK(void) ConsoleVRDPServer::VRDPCallbackVideoModeHint(void *pvCallback, unsigned cWidth, unsigned cHeight, unsigned cBitsPerPixel, unsigned uScreenId)
    11551157{
    11561158    ConsoleVRDPServer *server = static_cast<ConsoleVRDPServer*>(pvCallback);
    … …  
    11601162#endif /* VBOX_WITH_VRDP */
    11611163
    1162 ConsoleVRDPServer::ConsoleVRDPServer (Console *console)
     1164ConsoleVRDPServer::ConsoleVRDPServer(Console *console)
    11631165{
    11641166    mConsole = console;
    … …  
    11971199    m_InputSynch.fClientScrollLock = false;
    11981200
    1199     memset (maFramebuffers, 0, sizeof (maFramebuffers));
     1201    memset(maFramebuffers, 0, sizeof(maFramebuffers));
    12001202
    12011203    {
    … …  
    12171219}
    12181220
    1219 ConsoleVRDPServer::~ConsoleVRDPServer ()
    1220 {
    1221     Stop ();
     1221ConsoleVRDPServer::~ConsoleVRDPServer()
     1222{
     1223    Stop();
    12221224
    12231225#ifdef VBOX_WITH_VRDP
    … …  
    12361238        if (maFramebuffers[i])
    12371239        {
    1238             maFramebuffers[i]->Release ();
     1240            maFramebuffers[i]->Release();
    12391241            maFramebuffers[i] = NULL;
    12401242        }
    … …  
    12421244#endif /* VBOX_WITH_VRDP */
    12431245
    1244     if (RTCritSectIsInitialized (&mCritSect))
    1245     {
    1246         RTCritSectDelete (&mCritSect);
    1247         memset (&mCritSect, 0, sizeof (mCritSect));
    1248     }
    1249 }
    1250 
    1251 int ConsoleVRDPServer::Launch (void)
     1246    if (RTCritSectIsInitialized(&mCritSect))
     1247    {
     1248        RTCritSectDelete(&mCritSect);
     1249        memset(&mCritSect, 0, sizeof(mCritSect));
     1250    }
     1251}
     1252
     1253int ConsoleVRDPServer::Launch(void)
    12521254{
    12531255    LogFlowThisFunc(("\n"));
    12541256#ifdef VBOX_WITH_VRDP
    12551257    int rc = VINF_SUCCESS;
    1256     IVRDPServer *vrdpserver = mConsole->getVRDPServer ();
     1258    IVRDPServer *vrdpserver = mConsole->getVRDPServer();
    12571259    Assert(vrdpserver);
    12581260    BOOL vrdpEnabled = FALSE;
    12591261
    1260     HRESULT rc2 = vrdpserver->COMGETTER(Enabled) (&vrdpEnabled);
     1262    HRESULT rc2 = vrdpserver->COMGETTER(Enabled)(&vrdpEnabled);
    12611263    AssertComRC(rc2);
    12621264
    12631265    if (SUCCEEDED(rc2) && vrdpEnabled)
    12641266    {
    1265         if (loadVRDPLibrary ())
    1266         {
    1267             rc = mpfnVRDPCreateServer (&mCallbacks.header, this, (VRDPINTERFACEHDR **)&mpEntryPoints, &mhServer);
     1267        if (loadVRDPLibrary())
     1268        {
     1269            rc = mpfnVRDPCreateServer(&mCallbacks.header, this, (VRDPINTERFACEHDR **)&mpEntryPoints, &mhServer);
    12681270
    12691271            if (RT_SUCCESS(rc))
    12701272            {
    12711273#ifdef VBOX_WITH_USB
    1272                 remoteUSBThreadStart ();
     1274                remoteUSBThreadStart();
    12731275#endif /* VBOX_WITH_USB */
    12741276            }
    … …  
    12891291}
    12901292
    1291 void ConsoleVRDPServer::EnableConnections (void)
     1293void ConsoleVRDPServer::EnableConnections(void)
    12921294{
    12931295#ifdef VBOX_WITH_VRDP
    12941296    if (mpEntryPoints && mhServer)
    12951297    {
    1296         mpEntryPoints->VRDPEnableConnections (mhServer, true);
     1298        mpEntryPoints->VRDPEnableConnections(mhServer, true);
    12971299    }
    12981300#endif /* VBOX_WITH_VRDP */
    12991301}
    13001302
    1301 void ConsoleVRDPServer::DisconnectClient (uint32_t u32ClientId, bool fReconnect)
     1303void ConsoleVRDPServer::DisconnectClient(uint32_t u32ClientId, bool fReconnect)
    13021304{
    13031305#ifdef VBOX_WITH_VRDP
    13041306    if (mpEntryPoints && mhServer)
    13051307    {
    1306         mpEntryPoints->VRDPDisconnect (mhServer, u32ClientId, fReconnect);
     1308        mpEntryPoints->VRDPDisconnect(mhServer, u32ClientId, fReconnect);
    13071309    }
    13081310#endif /* VBOX_WITH_VRDP */
    13091311}
    13101312
    1311 void ConsoleVRDPServer::MousePointerUpdate (const VRDPCOLORPOINTER *pPointer)
     1313void ConsoleVRDPServer::MousePointerUpdate(const VRDPCOLORPOINTER *pPointer)
    13121314{
    13131315#ifdef VBOX_WITH_VRDP
    13141316    if (mpEntryPoints && mhServer)
    13151317    {
    1316         mpEntryPoints->VRDPColorPointer (mhServer, pPointer);
     1318        mpEntryPoints->VRDPColorPointer(mhServer, pPointer);
    13171319    }
    13181320#endif /* VBOX_WITH_VRDP */
    13191321}
    13201322
    1321 void ConsoleVRDPServer::MousePointerHide (void)
     1323void ConsoleVRDPServer::MousePointerHide(void)
    13221324{
    13231325#ifdef VBOX_WITH_VRDP
    13241326    if (mpEntryPoints && mhServer)
    13251327    {
    1326         mpEntryPoints->VRDPHidePointer (mhServer);
     1328        mpEntryPoints->VRDPHidePointer(mhServer);
    13271329    }
    13281330#endif /* VBOX_WITH_VRDP */
    13291331}
    13301332
    1331 void ConsoleVRDPServer::Stop (void)
     1333void ConsoleVRDPServer::Stop(void)
    13321334{
    13331335    Assert(VALID_PTR(this)); /** @todo r=bird: there are(/was) some odd cases where this buster was invalid on
    … …  
    13431345        if (mpEntryPoints && hServer)
    13441346        {
    1345             mpEntryPoints->VRDPDestroy (hServer);
     1347            mpEntryPoints->VRDPDestroy(hServer);
    13461348        }
    13471349    }
    … …  
    13491351
    13501352#ifdef VBOX_WITH_USB
    1351     remoteUSBThreadStop ();
     1353    remoteUSBThreadStop();
    13521354#endif /* VBOX_WITH_USB */
    13531355
    … …  
    13791381
    13801382#ifdef VBOX_WITH_USB
    1381 static DECLCALLBACK(int) threadRemoteUSB (RTTHREAD self, void *pvUser)
     1383static DECLCALLBACK(int) threadRemoteUSB(RTTHREAD self, void *pvUser)
    13821384{
    13831385    ConsoleVRDPServer *pOwner = (ConsoleVRDPServer *)pvUser;
    … …  
    13851387    LogFlow(("Console::threadRemoteUSB: start. owner = %p.\n", pOwner));
    13861388
    1387     pOwner->notifyRemoteUSBThreadRunning (self);
    1388 
    1389     while (pOwner->isRemoteUSBThreadRunning ())
     1389    pOwner->notifyRemoteUSBThreadRunning(self);
     1390
     1391    while (pOwner->isRemoteUSBThreadRunning())
    13901392    {
    13911393        RemoteUSBBackend *pRemoteUSBBackend = NULL;
    13921394
    1393         while ((pRemoteUSBBackend = pOwner->usbBackendGetNext (pRemoteUSBBackend)) != NULL)
    1394         {
    1395             pRemoteUSBBackend->PollRemoteDevices ();
    1396         }
    1397 
    1398         pOwner->waitRemoteUSBThreadEvent (VRDP_DEVICE_LIST_PERIOD_MS);
     1395        while ((pRemoteUSBBackend = pOwner->usbBackendGetNext(pRemoteUSBBackend)) != NULL)
     1396        {
     1397            pRemoteUSBBackend->PollRemoteDevices();
     1398        }
     1399
     1400        pOwner->waitRemoteUSBThreadEvent(VRDP_DEVICE_LIST_PERIOD_MS);
    13991401
    14001402        LogFlow(("Console::threadRemoteUSB: iteration. owner = %p.\n", pOwner));
    … …  
    14041406}
    14051407
    1406 void ConsoleVRDPServer::notifyRemoteUSBThreadRunning (RTTHREAD thread)
     1408void ConsoleVRDPServer::notifyRemoteUSBThreadRunning(RTTHREAD thread)
    14071409{
    14081410    mUSBBackends.thread = thread;
    14091411    mUSBBackends.fThreadRunning = true;
    1410     int rc = RTThreadUserSignal (thread);
     1412    int rc = RTThreadUserSignal(thread);
    14111413    AssertRC(rc);
    14121414}
    14131415
    1414 bool ConsoleVRDPServer::isRemoteUSBThreadRunning (void)
     1416bool ConsoleVRDPServer::isRemoteUSBThreadRunning(void)
    14151417{
    14161418    return mUSBBackends.fThreadRunning;
    14171419}
    14181420
    1419 void ConsoleVRDPServer::waitRemoteUSBThreadEvent (RTMSINTERVAL cMillies)
    1420 {
    1421     int rc = RTSemEventWait (mUSBBackends.event, cMillies);
    1422     Assert (RT_SUCCESS(rc) || rc == VERR_TIMEOUT);
     1421void ConsoleVRDPServer::waitRemoteUSBThreadEvent(RTMSINTERVAL cMillies)
     1422{
     1423    int rc = RTSemEventWait(mUSBBackends.event, cMillies);
     1424    Assert(RT_SUCCESS(rc) || rc == VERR_TIMEOUT);
    14231425    NOREF(rc);
    14241426}
    14251427
    1426 void ConsoleVRDPServer::remoteUSBThreadStart (void)
    1427 {
    1428     int rc = RTSemEventCreate (&mUSBBackends.event);
     1428void ConsoleVRDPServer::remoteUSBThreadStart(void)
     1429{
     1430    int rc = RTSemEventCreate(&mUSBBackends.event);
    14291431
    14301432    if (RT_FAILURE(rc))
    14311433    {
    1432         AssertFailed ();
     1434        AssertFailed();
    14331435        mUSBBackends.event = 0;
    14341436    }
    … …  
    14361438    if (RT_SUCCESS(rc))
    14371439    {
    1438         rc = RTThreadCreate (&mUSBBackends.thread, threadRemoteUSB, this, 65536,
     1440        rc = RTThreadCreate(&mUSBBackends.thread, threadRemoteUSB, this, 65536,
    14391441                             RTTHREADTYPE_VRDP_IO, RTTHREADFLAGS_WAITABLE, "remote usb");
    14401442    }
    … …  
    14481450    {
    14491451        /* Wait until the thread is ready. */
    1450         rc = RTThreadUserWait (mUSBBackends.thread, 60000);
     1452        rc = RTThreadUserWait(mUSBBackends.thread, 60000);
    14511453        AssertRC(rc);
    14521454        Assert (mUSBBackends.fThreadRunning || RT_FAILURE(rc));
    … …  
    14541456}
    14551457
    1456 void ConsoleVRDPServer::remoteUSBThreadStop (void)
     1458void ConsoleVRDPServer::remoteUSBThreadStop(void)
    14571459{
    14581460    mUSBBackends.fThreadRunning = false;
    … …  
    14621464        Assert (mUSBBackends.event != 0);
    14631465
    1464         RTSemEventSignal (mUSBBackends.event);
    1465 
    1466         int rc = RTThreadWait (mUSBBackends.thread, 60000, NULL);
     1466        RTSemEventSignal(mUSBBackends.event);
     1467
     1468        int rc = RTThreadWait(mUSBBackends.thread, 60000, NULL);
    14671469        AssertRC(rc);
    14681470
    … …  
    14721474    if (mUSBBackends.event)
    14731475    {
    1474         RTSemEventDestroy (mUSBBackends.event);
     1476        RTSemEventDestroy(mUSBBackends.event);
    14751477        mUSBBackends.event = 0;
    14761478    }
    … …  
    14781480#endif /* VBOX_WITH_USB */
    14791481
    1480 VRDPAuthResult ConsoleVRDPServer::Authenticate (const Guid &uuid, VRDPAuthGuestJudgement guestJudgement,
     1482VRDPAuthResult ConsoleVRDPServer::Authenticate(const Guid &uuid, VRDPAuthGuestJudgement guestJudgement,
    14811483                                                const char *pszUser, const char *pszPassword, const char *pszDomain,
    14821484                                                uint32_t u32ClientId)
    … …  
    14841486    VRDPAUTHUUID rawuuid;
    14851487
    1486     memcpy (rawuuid, ((Guid &)uuid).ptr (), sizeof (rawuuid));
     1488    memcpy(rawuuid, ((Guid &)uuid).ptr(), sizeof(rawuuid));
    14871489
    14881490    LogFlow(("ConsoleVRDPServer::Authenticate: uuid = %RTuuid, guestJudgement = %d, pszUser = %s, pszPassword = %s, pszDomain = %s, u32ClientId = %d\n",
    … …  
    15751577    }
    15761578
    1577     Assert (mAuthLibrary && (mpfnAuthEntry || mpfnAuthEntry2));
     1579    Assert(mAuthLibrary && (mpfnAuthEntry || mpfnAuthEntry2));
    15781580
    15791581    VRDPAuthResult result = mpfnAuthEntry2?
    1580                                 mpfnAuthEntry2 (&rawuuid, guestJudgement, pszUser, pszPassword, pszDomain, true, u32ClientId):
    1581                                 mpfnAuthEntry (&rawuuid, guestJudgement, pszUser, pszPassword, pszDomain);
     1582                                mpfnAuthEntry2(&rawuuid, guestJudgement, pszUser, pszPassword, pszDomain, true, u32ClientId):
     1583                                mpfnAuthEntry(&rawuuid, guestJudgement, pszUser, pszPassword, pszDomain);
    15821584
    15831585    switch (result)
    … …  
    16021604}
    16031605
    1604 void ConsoleVRDPServer::AuthDisconnect (const Guid &uuid, uint32_t u32ClientId)
     1606void ConsoleVRDPServer::AuthDisconnect(const Guid &uuid, uint32_t u32ClientId)
    16051607{
    16061608    VRDPAUTHUUID rawuuid;
    16071609
    1608     memcpy (rawuuid, ((Guid &)uuid).ptr (), sizeof (rawuuid));
     1610    memcpy(rawuuid, ((Guid &)uuid).ptr(), sizeof(rawuuid));
    16091611
    16101612    LogFlow(("ConsoleVRDPServer::AuthDisconnect: uuid = %RTuuid, u32ClientId = %d\n",
    16111613             rawuuid, u32ClientId));
    16121614
    1613     Assert (mAuthLibrary && (mpfnAuthEntry || mpfnAuthEntry2));
     1615    Assert(mAuthLibrary && (mpfnAuthEntry || mpfnAuthEntry2));
    16141616
    16151617    if (mpfnAuthEntry2)
    1616         mpfnAuthEntry2 (&rawuuid, VRDPAuthGuestNotAsked, NULL, NULL, NULL, false, u32ClientId);
    1617 }
    1618 
    1619 int ConsoleVRDPServer::lockConsoleVRDPServer (void)
    1620 {
    1621     int rc = RTCritSectEnter (&mCritSect);
     1618        mpfnAuthEntry2(&rawuuid, VRDPAuthGuestNotAsked, NULL, NULL, NULL, false, u32ClientId);
     1619}
     1620
     1621int ConsoleVRDPServer::lockConsoleVRDPServer(void)
     1622{
     1623    int rc = RTCritSectEnter(&mCritSect);
    16221624    AssertRC(rc);
    16231625    return rc;
    16241626}
    16251627
    1626 void ConsoleVRDPServer::unlockConsoleVRDPServer (void)
    1627 {
    1628     RTCritSectLeave (&mCritSect);
    1629 }
    1630 
    1631 DECLCALLBACK(int) ConsoleVRDPServer::ClipboardCallback (void *pvCallback,
    1632                                                         uint32_t u32ClientId,
    1633                                                         uint32_t u32Function,
    1634                                                         uint32_t u32Format,
    1635                                                         const void *pvData,
    1636                                                         uint32_t cbData)
     1628void ConsoleVRDPServer::unlockConsoleVRDPServer(void)
     1629{
     1630    RTCritSectLeave(&mCritSect);
     1631}
     1632
     1633DECLCALLBACK(int) ConsoleVRDPServer::ClipboardCallback(void *pvCallback,
     1634                                                       uint32_t u32ClientId,
     1635                                                       uint32_t u32Function,
     1636                                                       uint32_t u32Format,
     1637                                                       const void *pvData,
     1638                                                       uint32_t cbData)
    16371639{
    16381640    LogFlowFunc(("pvCallback = %p, u32ClientId = %d, u32Function = %d, u32Format = 0x%08X, pvData = %p, cbData = %d\n",
    … …  
    16511653            if (pServer->mpfnClipboardCallback)
    16521654            {
    1653                 pServer->mpfnClipboardCallback (VBOX_CLIPBOARD_EXT_FN_FORMAT_ANNOUNCE,
    1654                                                 u32Format,
    1655                                                 (void *)pvData,
    1656                                                 cbData);
     1655                pServer->mpfnClipboardCallback(VBOX_CLIPBOARD_EXT_FN_FORMAT_ANNOUNCE,
     1656                                               u32Format,
     1657                                               (void *)pvData,
     1658                                               cbData);
    16571659            }
    16581660        } break;
    … …  
    16621664            if (pServer->mpfnClipboardCallback)
    16631665            {
    1664                 pServer->mpfnClipboardCallback (VBOX_CLIPBOARD_EXT_FN_DATA_READ,
    1665                                                 u32Format,
    1666                                                 (void *)pvData,
    1667                                                 cbData);
     1666                pServer->mpfnClipboardCallback(VBOX_CLIPBOARD_EXT_FN_DATA_READ,
     1667                                               u32Format,
     1668                                               (void *)pvData,
     1669                                               cbData);
    16681670            }
    16691671        } break;
    … …  
    16761678}
    16771679
    1678 DECLCALLBACK(int) ConsoleVRDPServer::ClipboardServiceExtension (void *pvExtension,
    1679                                                                 uint32_t u32Function,
    1680                                                                 void *pvParms,
    1681                                                                 uint32_t cbParms)
     1680DECLCALLBACK(int) ConsoleVRDPServer::ClipboardServiceExtension(void *pvExtension,
     1681                                                               uint32_t u32Function,
     1682                                                               void *pvParms,
     1683                                                               uint32_t cbParms)
    16821684{
    16831685    LogFlowFunc(("pvExtension = %p, u32Function = %d, pvParms = %p, cbParms = %d\n",
    … …  
    17031705            if (mpEntryPoints && pServer->mhServer)
    17041706            {
    1705                 mpEntryPoints->VRDPClipboard (pServer->mhServer,
    1706                                               VRDP_CLIPBOARD_FUNCTION_FORMAT_ANNOUNCE,
    1707                                               pParms->u32Format,
    1708                                               NULL,
    1709                                               0,
    1710                                               NULL);
     1707                mpEntryPoints->VRDPClipboard(pServer->mhServer,
     1708                                             VRDP_CLIPBOARD_FUNCTION_FORMAT_ANNOUNCE,
     1709                                             pParms->u32Format,
     1710                                             NULL,
     1711                                             0,
     1712                                             NULL);
    17111713            }
    17121714        } break;
    … …  
    17201722            if (mpEntryPoints && pServer->mhServer)
    17211723            {
    1722                 mpEntryPoints->VRDPClipboard (pServer->mhServer,
    1723                                               VRDP_CLIPBOARD_FUNCTION_DATA_READ,
    1724                                               pParms->u32Format,
    1725                                               pParms->u.pvData,
    1726                                               pParms->cbData,
    1727                                               &pParms->cbData);
     1724                mpEntryPoints->VRDPClipboard(pServer->mhServer,
     1725                                             VRDP_CLIPBOARD_FUNCTION_DATA_READ,
     1726                                             pParms->u32Format,
     1727                                             pParms->u.pvData,
     1728                                             pParms->cbData,
     1729                                             &pParms->cbData);
    17281730            }
    17291731        } break;
    … …  
    17331735            if (mpEntryPoints && pServer->mhServer)
    17341736            {
    1735                 mpEntryPoints->VRDPClipboard (pServer->mhServer,
    1736                                               VRDP_CLIPBOARD_FUNCTION_DATA_WRITE,
    1737                                               pParms->u32Format,
    1738                                               pParms->u.pvData,
    1739                                               pParms->cbData,
    1740                                               NULL);
     1737                mpEntryPoints->VRDPClipboard(pServer->mhServer,
     1738                                             VRDP_CLIPBOARD_FUNCTION_DATA_WRITE,
     1739                                             pParms->u32Format,
     1740                                             pParms->u.pvData,
     1741                                             pParms->cbData,
     1742                                             NULL);
    17411743            }
    17421744        } break;
    … …  
    17501752}
    17511753
    1752 void ConsoleVRDPServer::ClipboardCreate (uint32_t u32ClientId)
    1753 {
    1754     int rc = lockConsoleVRDPServer ();
     1754void ConsoleVRDPServer::ClipboardCreate(uint32_t u32ClientId)
     1755{
     1756    int rc = lockConsoleVRDPServer();
    17551757
    17561758    if (RT_SUCCESS(rc))
    … …  
    17581760        if (mcClipboardRefs == 0)
    17591761        {
    1760             rc = HGCMHostRegisterServiceExtension (&mhClipboard, "VBoxSharedClipboard", ClipboardServiceExtension, this);
     1762            rc = HGCMHostRegisterServiceExtension(&mhClipboard, "VBoxSharedClipboard", ClipboardServiceExtension, this);
    17611763
    17621764            if (RT_SUCCESS(rc))
    … …  
    17661768        }
    17671769
    1768         unlockConsoleVRDPServer ();
    1769     }
    1770 }
    1771 
    1772 void ConsoleVRDPServer::ClipboardDelete (uint32_t u32ClientId)
    1773 {
    1774     int rc = lockConsoleVRDPServer ();
     1770        unlockConsoleVRDPServer();
     1771    }
     1772}
     1773
     1774void ConsoleVRDPServer::ClipboardDelete(uint32_t u32ClientId)
     1775{
     1776    int rc = lockConsoleVRDPServer();
    17751777
    17761778    if (RT_SUCCESS(rc))
    … …  
    17801782        if (mcClipboardRefs == 0)
    17811783        {
    1782             HGCMHostUnregisterServiceExtension (mhClipboard);
    1783         }
    1784 
    1785         unlockConsoleVRDPServer ();
     1784            HGCMHostUnregisterServiceExtension(mhClipboard);
     1785        }
     1786
     1787        unlockConsoleVRDPServer();
    17861788    }
    17871789}
    … …  
    17901792 * The ConsoleVRDPServer keeps a list of created backend instances.
    17911793 */
    1792 void ConsoleVRDPServer::USBBackendCreate (uint32_t u32ClientId, void **ppvIntercept)
     1794void ConsoleVRDPServer::USBBackendCreate(uint32_t u32ClientId, void **ppvIntercept)
    17931795{
    17941796#ifdef VBOX_WITH_USB
    … …  
    17961798
    17971799    /* Create a new instance of the USB backend for the new client. */
    1798     RemoteUSBBackend *pRemoteUSBBackend = new RemoteUSBBackend (mConsole, this, u32ClientId);
     1800    RemoteUSBBackend *pRemoteUSBBackend = new RemoteUSBBackend(mConsole, this, u32ClientId);
    17991801
    18001802    if (pRemoteUSBBackend)
    18011803    {
    1802         pRemoteUSBBackend->AddRef (); /* 'Release' called in USBBackendDelete. */
     1804        pRemoteUSBBackend->AddRef(); /* 'Release' called in USBBackendDelete. */
    18031805
    18041806        /* Append the new instance in the list. */
    1805         int rc = lockConsoleVRDPServer ();
     1807        int rc = lockConsoleVRDPServer();
    18061808
    18071809        if (RT_SUCCESS(rc))
    … …  
    18191821            mUSBBackends.pHead = pRemoteUSBBackend;
    18201822
    1821             unlockConsoleVRDPServer ();
     1823            unlockConsoleVRDPServer();
    18221824
    18231825            if (ppvIntercept)
    … …  
    18291831        if (RT_FAILURE(rc))
    18301832        {
    1831             pRemoteUSBBackend->Release ();
     1833            pRemoteUSBBackend->Release();
    18321834        }
    18331835    }
    … …  
    18351837}
    18361838
    1837 void ConsoleVRDPServer::USBBackendDelete (uint32_t u32ClientId)
     1839void ConsoleVRDPServer::USBBackendDelete(uint32_t u32ClientId)
    18381840{
    18391841#ifdef VBOX_WITH_USB
    … …  
    18431845
    18441846    /* Find the instance. */
    1845     int rc = lockConsoleVRDPServer ();
     1847    int rc = lockConsoleVRDPServer();
    18461848
    18471849    if (RT_SUCCESS(rc))
    18481850    {
    1849         pRemoteUSBBackend = usbBackendFind (u32ClientId);
     1851        pRemoteUSBBackend = usbBackendFind(u32ClientId);
    18501852
    18511853        if (pRemoteUSBBackend)
    18521854        {
    18531855            /* Notify that it will be deleted. */
    1854             pRemoteUSBBackend->NotifyDelete ();
    1855         }
    1856 
    1857         unlockConsoleVRDPServer ();
     1856            pRemoteUSBBackend->NotifyDelete();
     1857        }
     1858
     1859        unlockConsoleVRDPServer();
    18581860    }
    18591861
    … …  
    18611863    {
    18621864        /* Here the instance has been excluded from the list and can be dereferenced. */
    1863         pRemoteUSBBackend->Release ();
     1865        pRemoteUSBBackend->Release();
    18641866    }
    18651867#endif
    18661868}
    18671869
    1868 void *ConsoleVRDPServer::USBBackendRequestPointer (uint32_t u32ClientId, const Guid *pGuid)
     1870void *ConsoleVRDPServer::USBBackendRequestPointer(uint32_t u32ClientId, const Guid *pGuid)
    18691871{
    18701872#ifdef VBOX_WITH_USB
    … …  
    18721874
    18731875    /* Find the instance. */
    1874     int rc = lockConsoleVRDPServer ();
     1876    int rc = lockConsoleVRDPServer();
    18751877
    18761878    if (RT_SUCCESS(rc))
    18771879    {
    1878         pRemoteUSBBackend = usbBackendFind (u32ClientId);
     1880        pRemoteUSBBackend = usbBackendFind(u32ClientId);
    18791881
    18801882        if (pRemoteUSBBackend)
    18811883        {
    18821884            /* Inform the backend instance that it is referenced by the Guid. */
    1883             bool fAdded = pRemoteUSBBackend->addUUID (pGuid);
     1885            bool fAdded = pRemoteUSBBackend->addUUID(pGuid);
    18841886
    18851887            if (fAdded)
    18861888            {
    18871889                /* Reference the instance because its pointer is being taken. */
    1888                 pRemoteUSBBackend->AddRef (); /* 'Release' is called in USBBackendReleasePointer. */
     1890                pRemoteUSBBackend->AddRef(); /* 'Release' is called in USBBackendReleasePointer. */
    18891891            }
    18901892            else
    … …  
    18941896        }
    18951897
    1896         unlockConsoleVRDPServer ();
     1898        unlockConsoleVRDPServer();
    18971899    }
    18981900
    18991901    if (pRemoteUSBBackend)
    19001902    {
    1901         return pRemoteUSBBackend->GetBackendCallbackPointer ();
     1903        return pRemoteUSBBackend->GetBackendCallbackPointer();
    19021904    }
    19031905
    … …  
    19061908}
    19071909
    1908 void ConsoleVRDPServer::USBBackendReleasePointer (const Guid *pGuid)
     1910void ConsoleVRDPServer::USBBackendReleasePointer(const Guid *pGuid)
    19091911{
    19101912#ifdef VBOX_WITH_USB
    … …  
    19121914
    19131915    /* Find the instance. */
    1914     int rc = lockConsoleVRDPServer ();
     1916    int rc = lockConsoleVRDPServer();
    19151917
    19161918    if (RT_SUCCESS(rc))
    19171919    {
    1918         pRemoteUSBBackend = usbBackendFindByUUID (pGuid);
     1920        pRemoteUSBBackend = usbBackendFindByUUID(pGuid);
    19191921
    19201922        if (pRemoteUSBBackend)
    19211923        {
    1922             pRemoteUSBBackend->removeUUID (pGuid);
    1923         }
    1924 
    1925         unlockConsoleVRDPServer ();
     1924            pRemoteUSBBackend->removeUUID(pGuid);
     1925        }
     1926
     1927        unlockConsoleVRDPServer();
    19261928
    19271929        if (pRemoteUSBBackend)
    19281930        {
    1929             pRemoteUSBBackend->Release ();
     1931            pRemoteUSBBackend->Release();
    19301932        }
    19311933    }
    … …  
    19331935}
    19341936
    1935 RemoteUSBBackend *ConsoleVRDPServer::usbBackendGetNext (RemoteUSBBackend *pRemoteUSBBackend)
     1937RemoteUSBBackend *ConsoleVRDPServer::usbBackendGetNext(RemoteUSBBackend *pRemoteUSBBackend)
    19361938{
    19371939    LogFlow(("ConsoleVRDPServer::usbBackendGetNext: pBackend = %p\n", pRemoteUSBBackend));
    … …  
    19401942#ifdef VBOX_WITH_USB
    19411943
    1942     int rc = lockConsoleVRDPServer ();
     1944    int rc = lockConsoleVRDPServer();
    19431945
    19441946    if (RT_SUCCESS(rc))
    … …  
    19571959        if (pNextRemoteUSBBackend)
    19581960        {
    1959             pNextRemoteUSBBackend->AddRef ();
    1960         }
    1961 
    1962         unlockConsoleVRDPServer ();
     1961            pNextRemoteUSBBackend->AddRef();
     1962        }
     1963
     1964        unlockConsoleVRDPServer();
    19631965
    19641966        if (pRemoteUSBBackend)
    19651967        {
    1966             pRemoteUSBBackend->Release ();
     1968            pRemoteUSBBackend->Release();
    19671969        }
    19681970    }
    … …  
    19741976#ifdef VBOX_WITH_USB
    19751977/* Internal method. Called under the ConsoleVRDPServerLock. */
    1976 RemoteUSBBackend *ConsoleVRDPServer::usbBackendFind (uint32_t u32ClientId)
     1978RemoteUSBBackend *ConsoleVRDPServer::usbBackendFind(uint32_t u32ClientId)
    19771979{
    19781980    RemoteUSBBackend *pRemoteUSBBackend = mUSBBackends.pHead;
    … …  
    19801982    while (pRemoteUSBBackend)
    19811983    {
    1982         if (pRemoteUSBBackend->ClientId () == u32ClientId)
     1984        if (pRemoteUSBBackend->ClientId() == u32ClientId)
    19831985        {
    19841986            break;
    … …  
    19921994
    19931995/* Internal method. Called under the ConsoleVRDPServerLock. */
    1994 RemoteUSBBackend *ConsoleVRDPServer::usbBackendFindByUUID (const Guid *pGuid)
     1996RemoteUSBBackend *ConsoleVRDPServer::usbBackendFindByUUID(const Guid *pGuid)
    19951997{
    19961998    RemoteUSBBackend *pRemoteUSBBackend = mUSBBackends.pHead;
    … …  
    19982000    while (pRemoteUSBBackend)
    19992001    {
    2000         if (pRemoteUSBBackend->findUUID (pGuid))
     2002        if (pRemoteUSBBackend->findUUID(pGuid))
    20012003        {
    20022004            break;
    … …  
    20112013
    20122014/* Internal method. Called by the backend destructor. */
    2013 void ConsoleVRDPServer::usbBackendRemoveFromList (RemoteUSBBackend *pRemoteUSBBackend)
     2015void ConsoleVRDPServer::usbBackendRemoveFromList(RemoteUSBBackend *pRemoteUSBBackend)
    20142016{
    20152017#ifdef VBOX_WITH_USB
    2016     int rc = lockConsoleVRDPServer ();
     2018    int rc = lockConsoleVRDPServer();
    20172019    AssertRC(rc);
    20182020
    … …  
    20382040    pRemoteUSBBackend->pNext = pRemoteUSBBackend->pPrev = NULL;
    20392041
    2040     unlockConsoleVRDPServer ();
     2042    unlockConsoleVRDPServer();
    20412043#endif
    20422044}
    20432045
    20442046
    2045 void ConsoleVRDPServer::SendUpdate (unsigned uScreenId, void *pvUpdate, uint32_t cbUpdate) const
     2047void ConsoleVRDPServer::SendUpdate(unsigned uScreenId, void *pvUpdate, uint32_t cbUpdate) const
    20462048{
    20472049#ifdef VBOX_WITH_VRDP
    20482050    if (mpEntryPoints && mhServer)
    20492051    {
    2050         mpEntryPoints->VRDPUpdate (mhServer, uScreenId, pvUpdate, cbUpdate);
     2052        mpEntryPoints->VRDPUpdate(mhServer, uScreenId, pvUpdate, cbUpdate);
    20512053    }
    20522054#endif
    20532055}
    20542056
    2055 void ConsoleVRDPServer::SendResize (void) const
     2057void ConsoleVRDPServer::SendResize(void) const
    20562058{
    20572059#ifdef VBOX_WITH_VRDP
    20582060    if (mpEntryPoints && mhServer)
    20592061    {
    2060         mpEntryPoints->VRDPResize (mhServer);
     2062        mpEntryPoints->VRDPResize(mhServer);
    20612063    }
    20622064#endif
    20632065}
    20642066
    2065 void ConsoleVRDPServer::SendUpdateBitmap (unsigned uScreenId, uint32_t x, uint32_t y, uint32_t w, uint32_t h) const
     2067void ConsoleVRDPServer::SendUpdateBitmap(unsigned uScreenId, uint32_t x, uint32_t y, uint32_t w, uint32_t h) const
    20662068{
    20672069#ifdef VBOX_WITH_VRDP
    … …  
    20732075    if (mpEntryPoints && mhServer)
    20742076    {
    2075         mpEntryPoints->VRDPUpdate (mhServer, uScreenId, &update, sizeof (update));
     2077        mpEntryPoints->VRDPUpdate(mhServer, uScreenId, &update, sizeof(update));
    20762078    }
    20772079#endif
    20782080}
    20792081
    2080 void ConsoleVRDPServer::SendAudioSamples (void *pvSamples, uint32_t cSamples, VRDPAUDIOFORMAT format) const
     2082void ConsoleVRDPServer::SendAudioSamples(void *pvSamples, uint32_t cSamples, VRDPAUDIOFORMAT format) const
    20812083{
    20822084#ifdef VBOX_WITH_VRDP
    20832085    if (mpEntryPoints && mhServer)
    20842086    {
    2085         mpEntryPoints->VRDPAudioSamples (mhServer, pvSamples, cSamples, format);
     2087        mpEntryPoints->VRDPAudioSamples(mhServer, pvSamples, cSamples, format);
    20862088    }
    20872089#endif
    20882090}
    20892091
    2090 void ConsoleVRDPServer::SendAudioVolume (uint16_t left, uint16_t right) const
     2092void ConsoleVRDPServer::SendAudioVolume(uint16_t left, uint16_t right) const
    20912093{
    20922094#ifdef VBOX_WITH_VRDP
    20932095    if (mpEntryPoints && mhServer)
    20942096    {
    2095         mpEntryPoints->VRDPAudioVolume (mhServer, left, right);
     2097        mpEntryPoints->VRDPAudioVolume(mhServer, left, right);
    20962098    }
    20972099#endif
    20982100}
    20992101
    2100 void ConsoleVRDPServer::SendUSBRequest (uint32_t u32ClientId, void *pvParms, uint32_t cbParms) const
     2102void ConsoleVRDPServer::SendUSBRequest(uint32_t u32ClientId, void *pvParms, uint32_t cbParms) const
    21012103{
    21022104#ifdef VBOX_WITH_VRDP
    21032105    if (mpEntryPoints && mhServer)
    21042106    {
    2105         mpEntryPoints->VRDPUSBRequest (mhServer, u32ClientId, pvParms, cbParms);
     2107        mpEntryPoints->VRDPUSBRequest(mhServer, u32ClientId, pvParms, cbParms);
    21062108    }
    21072109#endif
    21082110}
    21092111
    2110 void ConsoleVRDPServer::QueryInfo (uint32_t index, void *pvBuffer, uint32_t cbBuffer, uint32_t *pcbOut) const
     2112void ConsoleVRDPServer::QueryInfo(uint32_t index, void *pvBuffer, uint32_t cbBuffer, uint32_t *pcbOut) const
    21112113{
    21122114#ifdef VBOX_WITH_VRDP
    21132115    if (index == VRDP_QI_PORT)
    21142116    {
    2115         uint32_t cbOut = sizeof (int32_t);
     2117        uint32_t cbOut = sizeof(int32_t);
    21162118
    21172119        if (cbBuffer >= cbOut)
    … …  
    21232125    else if (mpEntryPoints && mhServer)
    21242126    {
    2125         mpEntryPoints->VRDPQueryInfo (mhServer, index, pvBuffer, cbBuffer, pcbOut);
     2127        mpEntryPoints->VRDPQueryInfo(mhServer, index, pvBuffer, cbBuffer, pcbOut);
    21262128    }
    21272129#endif
    … …  
    21302132#ifdef VBOX_WITH_VRDP
    21312133/* note: static function now! */
    2132 bool ConsoleVRDPServer::loadVRDPLibrary (void)
     2134bool ConsoleVRDPServer::loadVRDPLibrary(void)
    21332135{
    21342136    int rc = VINF_SUCCESS;
    … …  
    21362138    if (!mVRDPLibrary)
    21372139    {
    2138         rc = SUPR3HardenedLdrLoadAppPriv ("VBoxVRDP", &mVRDPLibrary);
     2140        rc = SUPR3HardenedLdrLoadAppPriv("VBoxVRDP", &mVRDPLibrary);
    21392141
    21402142        if (RT_SUCCESS(rc))
    … …  
    21812183        if (mVRDPLibrary)
    21822184        {
    2183             RTLdrClose (mVRDPLibrary);
     2185            RTLdrClose(mVRDPLibrary);
    21842186            mVRDPLibrary = NULL;
    21852187        }
    … …  
    22132215void RemoteDisplayInfo::FinalRelease()
    22142216{
    2215     uninit ();
     2217    uninit();
    22162218}
    22172219
    … …  
    22222224 * Initializes the guest object.
    22232225 */
    2224 HRESULT RemoteDisplayInfo::init (Console *aParent)
     2226HRESULT RemoteDisplayInfo::init(Console *aParent)
    22252227{
    22262228    LogFlowThisFunc(("aParent=%p\n", aParent));
    … …  
    22602262
    22612263#define IMPL_GETTER_BOOL(_aType, _aName, _aIndex)                         \
    2262     STDMETHODIMP RemoteDisplayInfo::COMGETTER(_aName) (_aType *a##_aName) \
     2264    STDMETHODIMP RemoteDisplayInfo::COMGETTER(_aName)(_aType *a##_aName) \
    22632265    {                                                                     \
    22642266        if (!a##_aName)                                                   \
    … …  
    22742276        uint32_t cbOut = 0;                                               \
    22752277                                                                          \
    2276         mParent->consoleVRDPServer ()->QueryInfo                          \
    2277             (_aIndex, &value, sizeof (value), &cbOut);                    \
     2278        mParent->consoleVRDPServer()->QueryInfo                           \
     2279            (_aIndex, &value, sizeof(value), &cbOut);                     \
    22782280                                                                          \
    22792281        *a##_aName = cbOut? !!value: FALSE;                               \
    … …  
    22842286
    22852287#define IMPL_GETTER_SCALAR(_aType, _aName, _aIndex, _aValueMask)          \
    2286     STDMETHODIMP RemoteDisplayInfo::COMGETTER(_aName) (_aType *a##_aName) \
     2288    STDMETHODIMP RemoteDisplayInfo::COMGETTER(_aName)(_aType *a##_aName) \
    22872289    {                                                                     \
    22882290        if (!a##_aName)                                                   \
    … …  
    22982300        uint32_t cbOut = 0;                                               \
    22992301                                                                          \
    2300         mParent->consoleVRDPServer ()->QueryInfo                          \
    2301             (_aIndex, &value, sizeof (value), &cbOut);                    \
     2302        mParent->consoleVRDPServer()->QueryInfo                           \
     2303            (_aIndex, &value, sizeof(value), &cbOut);                     \
    23022304                                                                          \
    23032305        if (_aValueMask) value &= (_aValueMask);                          \
    … …  
    23092311
    23102312#define IMPL_GETTER_BSTR(_aType, _aName, _aIndex)                         \
    2311     STDMETHODIMP RemoteDisplayInfo::COMGETTER(_aName) (_aType *a##_aName) \
     2313    STDMETHODIMP RemoteDisplayInfo::COMGETTER(_aName)(_aType *a##_aName) \
    23122314    {                                                                     \
    23132315        if (!a##_aName)                                                   \
    … …  
    23222324        uint32_t cbOut = 0;                                               \
    23232325                                                                          \
    2324         mParent->consoleVRDPServer ()->QueryInfo                          \
     2326        mParent->consoleVRDPServer()->QueryInfo                           \
    23252327            (_aIndex, NULL, 0, &cbOut);                                   \
    23262328                                                                          \
    … …  
    23322334        }                                                                 \
    23332335                                                                          \
    2334         char *pchBuffer = (char *)RTMemTmpAlloc (cbOut);                  \
     2336        char *pchBuffer = (char *)RTMemTmpAlloc(cbOut);                   \
    23352337                                                                          \
    23362338        if (!pchBuffer)                                                   \
    … …  
    23422344        }                                                                 \
    23432345                                                                          \
    2344         mParent->consoleVRDPServer ()->QueryInfo                          \
     2346        mParent->consoleVRDPServer()->QueryInfo                           \
    23452347            (_aIndex, pchBuffer, cbOut, &cbOut);                          \
    23462348                                                                          \
    … …  
    23492351        str.cloneTo(a##_aName);                                           \
    23502352                                                                          \
    2351         RTMemTmpFree (pchBuffer);                                         \
     2353        RTMemTmpFree(pchBuffer);                                          \
    23522354                                                                          \
    23532355        return S_OK;                                                      \

  • trunk/src/VBox/Main/GuestImpl.cpp

    r32138 r32718  
    196196        LONG64 u64Timestamp;
    197197        Bstr flags;
    198         hr = mParent->machine()->GetGuestProperty(Bstr("/VirtualBox/GuestAdd/Version"),
     198        hr = mParent->machine()->GetGuestProperty(Bstr("/VirtualBox/GuestAdd/Version").raw(),
    199199                                                  addVersion.asOutParam(), &u64Timestamp, flags.asOutParam());
    200200        if (hr == S_OK)
    201201        {
    202202            Bstr addRevision;
    203             hr = mParent->machine()->GetGuestProperty(Bstr("/VirtualBox/GuestAdd/Revision"),
     203            hr = mParent->machine()->GetGuestProperty(Bstr("/VirtualBox/GuestAdd/Revision").raw(),
    204204                                                      addRevision.asOutParam(), &u64Timestamp, flags.asOutParam());
    205205            if (   hr == S_OK
    … …  
    640640                case PROC_STS_STARTED:
    641641                    LogRel(("Guest process (PID %u) started\n", pCBData->u32PID)); /** @todo Add process name */
    642                     hr = it->second.pProgress->SetNextOperation(BstrFmt(tr("Waiting for process to exit ...")), 1 /* Weight */);
     642                    hr = it->second.pProgress->SetNextOperation(Bstr(tr("Waiting for process to exit ...")).raw(), 1 /* Weight */);
    643643                    AssertComRC(hr);
    644644                    break;
    … …  
    978978        {
    979979            rc = progress->init(static_cast<IGuest*>(this),
    980                                 BstrFmt(tr("Executing process")),
     980                                Bstr(tr("Executing process")).raw(),
    981981                                TRUE,
    982                                 2,                                      /* Number of operations. */
    983                                 BstrFmt(tr("Starting process ...")));   /* Description of first stage. */
     982                                2,                                          /* Number of operations. */
     983                                Bstr(tr("Starting process ...")).raw());    /* Description of first stage. */
    984984        }
    985985        if (FAILED(rc)) return rc;
    … …  
    12761276        {
    12771277            rc = progress->init(static_cast<IGuest*>(this),
    1278                                 BstrFmt(tr("Getting output of process")),
     1278                                Bstr(tr("Getting output of process")).raw(),
    12791279                                TRUE);
    12801280        }

  • trunk/src/VBox/Main/HostNetworkInterfaceImpl.cpp

    r31539 r32718  
    6666                      aInterfaceName.raw(), aGuid.toString().c_str()));
    6767
    68     ComAssertRet(aInterfaceName, E_INVALIDARG);
     68    ComAssertRet(!aInterfaceName.isEmpty(), E_INVALIDARG);
    6969    ComAssertRet(!aGuid.isEmpty(), E_INVALIDARG);
    7070
    … …  
    427427            {
    428428                m.realIPAddress = 0;
    429                 if (FAILED(mVBox->SetExtraData(BstrFmt("HostOnly/%ls/IPAddress", mInterfaceName.raw()), NULL)))
     429                if (FAILED(mVBox->SetExtraData(BstrFmt("HostOnly/%ls/IPAddress", mInterfaceName.raw()).raw(), NULL)))
    430430                    return E_FAIL;
    431                 if (FAILED(mVBox->SetExtraData(BstrFmt("HostOnly/%ls/IPNetMask", mInterfaceName.raw()), NULL)))
     431                if (FAILED(mVBox->SetExtraData(BstrFmt("HostOnly/%ls/IPNetMask", mInterfaceName.raw()).raw(), NULL)))
    432432                    return E_FAIL;
    433433                return S_OK;
    … …  
    455455                m.realIPAddress   = ip;
    456456                m.realNetworkMask = mask;
    457                 if (FAILED(mVBox->SetExtraData(BstrFmt("HostOnly/%ls/IPAddress", mInterfaceName.raw()), Bstr(aIPAddress))))
     457                if (FAILED(mVBox->SetExtraData(BstrFmt("HostOnly/%ls/IPAddress", mInterfaceName.raw()).raw(), Bstr(aIPAddress).raw())))
    458458                    return E_FAIL;
    459                 if (FAILED(mVBox->SetExtraData(BstrFmt("HostOnly/%ls/IPNetMask", mInterfaceName.raw()), Bstr(aNetMask))))
     459                if (FAILED(mVBox->SetExtraData(BstrFmt("HostOnly/%ls/IPNetMask", mInterfaceName.raw()).raw(), Bstr(aNetMask).raw())))
    460460                    return E_FAIL;
    461461                return S_OK;
    … …  
    491491        if (aIPV6MaskPrefixLength == 0)
    492492            aIPV6MaskPrefixLength = 64;
    493         rc = NetIfEnableStaticIpConfigV6(mVBox, this, m.IPV6Address, aIPV6Address, aIPV6MaskPrefixLength);
     493        rc = NetIfEnableStaticIpConfigV6(mVBox, this, m.IPV6Address.raw(), aIPV6Address, aIPV6MaskPrefixLength);
    494494        if (RT_FAILURE(rc))
    495495        {
    … …  
    501501            m.realIPV6Address = aIPV6Address;
    502502            m.realIPV6PrefixLength = aIPV6MaskPrefixLength;
    503             if (FAILED(mVBox->SetExtraData(BstrFmt("HostOnly/%ls/IPV6Address", mInterfaceName.raw()), Bstr(aIPV6Address))))
     503            if (FAILED(mVBox->SetExtraData(BstrFmt("HostOnly/%ls/IPV6Address", mInterfaceName.raw()).raw(), Bstr(aIPV6Address).raw())))
    504504                return E_FAIL;
    505             if (FAILED(mVBox->SetExtraData(BstrFmt("HostOnly/%ls/IPV6NetMask", mInterfaceName.raw()),
    506                                            BstrFmt("%u", aIPV6MaskPrefixLength))))
     505            if (FAILED(mVBox->SetExtraData(BstrFmt("HostOnly/%ls/IPV6NetMask", mInterfaceName.raw()).raw(),
     506                                           BstrFmt("%u", aIPV6MaskPrefixLength).raw())))
    507507                return E_FAIL;
    508508        }
    … …  
    560560    {
    561561        Bstr tmpAddr, tmpMask;
    562         hrc = mVBox->GetExtraData(BstrFmt("HostOnly/%ls/IPAddress", mInterfaceName.raw()), tmpAddr.asOutParam());
    563         hrc = mVBox->GetExtraData(BstrFmt("HostOnly/%ls/IPNetMask", mInterfaceName.raw()), tmpMask.asOutParam());
     562        hrc = mVBox->GetExtraData(BstrFmt("HostOnly/%ls/IPAddress", mInterfaceName.raw()).raw(), tmpAddr.asOutParam());
     563        hrc = mVBox->GetExtraData(BstrFmt("HostOnly/%ls/IPNetMask", mInterfaceName.raw()).raw(), tmpMask.asOutParam());
    564564        if (tmpAddr.isEmpty())
    565565            tmpAddr = getDefaultIPv4Address(mInterfaceName);
    … …  
    573573    {
    574574        Bstr tmpPrefixLen;
    575         hrc = mVBox->GetExtraData(BstrFmt("HostOnly/%ls/IPV6Address", mInterfaceName.raw()), m.IPV6Address.asOutParam());
     575        hrc = mVBox->GetExtraData(BstrFmt("HostOnly/%ls/IPV6Address", mInterfaceName.raw()).raw(), m.IPV6Address.asOutParam());
    576576        if (!m.IPV6Address.isEmpty())
    577577        {
    578             hrc = mVBox->GetExtraData(BstrFmt("HostOnly/%ls/IPV6PrefixLen", mInterfaceName.raw()), tmpPrefixLen.asOutParam());
     578            hrc = mVBox->GetExtraData(BstrFmt("HostOnly/%ls/IPV6PrefixLen", mInterfaceName.raw()).raw(), tmpPrefixLen.asOutParam());
    579579            if (SUCCEEDED(hrc) && !tmpPrefixLen.isEmpty())
    580580                m.IPV6NetworkMaskPrefixLength = Utf8Str(tmpPrefixLen).toUInt32();

  • trunk/src/VBox/Main/HostUSBDeviceImpl.cpp

    r31892 r32718  
    578578     */
    579579    LogFlowThisFunc(("{%s} Calling machine->onUSBDeviceDetach()...\n", mName));
    580     HRESULT hrc = mMachine->onUSBDeviceDetach(mId.toUtf16(), NULL);
     580    HRESULT hrc = mMachine->onUSBDeviceDetach(mId.toUtf16().raw(), NULL);
    581581    LogFlowThisFunc(("{%s} Done machine->onUSBDeviceDetach()=%Rhrc\n", mName, hrc));
    582582    NOREF(hrc);

  • trunk/src/VBox/Main/KeyboardImpl.cpp

    r30681 r32718  
    55
    66/*
    7  * Copyright (C) 2006-2008 Oracle Corporation
     7 * Copyright (C) 2006-2010 Oracle Corporation
    88 *
    99 * This file is part of VirtualBox Open Source Edition (OSE), as
    … …  
    9999 * @param parent handle of our parent object
    100100 */
    101 HRESULT Keyboard::init (Console *aParent)
     101HRESULT Keyboard::init(Console *aParent)
    102102{
    103103    LogFlowThisFunc(("aParent=%p\n", aParent));
    … …  
    149149 * @param scancode The scancode to send
    150150 */
    151 STDMETHODIMP Keyboard::PutScancode (LONG scancode)
     151STDMETHODIMP Keyboard::PutScancode(LONG scancode)
    152152{
    153153    HRESULT rc = S_OK;
    … …  
    193193                      This value can be NULL.
    194194 */
    195 STDMETHODIMP Keyboard::PutScancodes (ComSafeArrayIn (LONG, scancodes),
    196                                      ULONG *codesStored)
     195STDMETHODIMP Keyboard::PutScancodes(ComSafeArrayIn(LONG, scancodes),
     196                                    ULONG *codesStored)
    197197{
    198198    HRESULT rc = S_OK;
    199199
    200     if (ComSafeArrayInIsNull (scancodes))
     200    if (ComSafeArrayInIsNull(scancodes))
    201201        return E_INVALIDARG;
    202202
    … …  
    224224        return rc;
    225225
    226     com::SafeArray<LONG> keys (ComSafeArrayInArg (scancodes));
     226    com::SafeArray<LONG> keys(ComSafeArrayInArg(scancodes));
    227227    int vrc = VINF_SUCCESS;
    228228
    … …  
    287287 * @param   pDrvIns     The driver instance data.
    288288 */
    289 DECLCALLBACK(void) Keyboard::drvDestruct (PPDMDRVINS pDrvIns)
     289DECLCALLBACK(void) Keyboard::drvDestruct(PPDMDRVINS pDrvIns)
    290290{
    291291    PDRVMAINKEYBOARD pData = PDMINS_2_DATA(pDrvIns, PDRVMAINKEYBOARD);
    … …  
    306306}
    307307
    308 DECLCALLBACK(void) keyboardLedStatusChange (PPDMIKEYBOARDCONNECTOR pInterface, PDMKEYBLEDS enmLeds)
    309 {
    310     PDRVMAINKEYBOARD pDrv = PPDMIKEYBOARDCONNECTOR_2_MAINKEYBOARD (pInterface);
    311     pDrv->pKeyboard->getParent()->onKeyboardLedsChange (!!(enmLeds & PDMKEYBLEDS_NUMLOCK),
    312                                                         !!(enmLeds & PDMKEYBLEDS_CAPSLOCK),
    313                                                         !!(enmLeds & PDMKEYBLEDS_SCROLLLOCK));
     308DECLCALLBACK(void) keyboardLedStatusChange(PPDMIKEYBOARDCONNECTOR pInterface,
     309                                           PDMKEYBLEDS enmLeds)
     310{
     311    PDRVMAINKEYBOARD pDrv = PPDMIKEYBOARDCONNECTOR_2_MAINKEYBOARD(pInterface);
     312    pDrv->pKeyboard->getParent()->onKeyboardLedsChange(!!(enmLeds & PDMKEYBLEDS_NUMLOCK),
     313                                                       !!(enmLeds & PDMKEYBLEDS_CAPSLOCK),
     314                                                       !!(enmLeds & PDMKEYBLEDS_SCROLLLOCK));
    314315}
    315316
    … …  
    331332 * @copydoc FNPDMDRVCONSTRUCT
    332333 */
    333 DECLCALLBACK(int) Keyboard::drvConstruct (PPDMDRVINS pDrvIns, PCFGMNODE pCfg, uint32_t fFlags)
    334 {
    335     PDRVMAINKEYBOARD pData = PDMINS_2_DATA (pDrvIns, PDRVMAINKEYBOARD);
     334DECLCALLBACK(int) Keyboard::drvConstruct(PPDMDRVINS pDrvIns, PCFGMNODE pCfg,
     335                                         uint32_t fFlags)
     336{
     337    PDRVMAINKEYBOARD pData = PDMINS_2_DATA(pDrvIns, PDRVMAINKEYBOARD);
    336338    LogFlow(("Keyboard::drvConstruct: iInstance=%d\n", pDrvIns->iInstance));
    337339    PDMDRV_CHECK_VERSIONS_RETURN(pDrvIns);
    … …  
    340342     * Validate configuration.
    341343     */
    342     if (!CFGMR3AreValuesValid (pCfg, "Object\0"))
     344    if (!CFGMR3AreValuesValid(pCfg, "Object\0"))
    343345        return VERR_PDM_DRVINS_UNKNOWN_CFG_VALUES;
    344346    AssertMsgReturn(PDMDrvHlpNoAttach(pDrvIns) == VERR_PDM_NO_ATTACHED_DRIVER,
    … …  
    360362    if (!pData->pUpPort)
    361363    {
    362         AssertMsgFailed (("Configuration error: No keyboard port interface above!\n"));
     364        AssertMsgFailed(("Configuration error: No keyboard port interface above!\n"));
    363365        return VERR_PDM_MISSING_INTERFACE_ABOVE;
    364366    }
    … …  
    368370     */
    369371    void *pv;
    370     int rc = CFGMR3QueryPtr (pCfg, "Object", &pv);
     372    int rc = CFGMR3QueryPtr(pCfg, "Object", &pv);
    371373    if (RT_FAILURE(rc))
    372374    {
    373         AssertMsgFailed (("Configuration error: No/bad \"Object\" value! rc=%Rrc\n", rc));
     375        AssertMsgFailed(("Configuration error: No/bad \"Object\" value! rc=%Rrc\n", rc));
    374376        return rc;
    375377    }

  • trunk/src/VBox/Main/MachineImpl.cpp

    r32705 r32718  
    32413241    rc = progress->init(mParent,
    32423242                        static_cast<IMachine*>(this),
    3243                         Bstr(tr("Spawning session")),
     3243                        Bstr(tr("Spawning session")).raw(),
    32443244                        TRUE /* aCancelable */,
    32453245                        fTeleporterEnabled ? 20 : 10 /* uTotalOperationsWeight */,
    3246                         Bstr(tr("Spawning session")),
     3246                        Bstr(tr("Spawning session")).raw(),
    32473247                        2 /* uFirstOperationWeight */,
    32483248                        fTeleporterEnabled ? 3 : 1 /* cOtherProgressObjectOperations */);
    … …  
    40554055        Bstr bstrValue(aValue);
    40564056
    4057         if (!mParent->onExtraDataCanChange(mData->mUuid, aKey, bstrValue, error))
     4057        if (!mParent->onExtraDataCanChange(mData->mUuid, aKey, bstrValue.raw(), error))
    40584058        {
    40594059            const char *sep = error.isEmpty() ? "" : ": ";
    … …  
    43404340    pTask->pProgress->init(getVirtualBox(),
    43414341                           static_cast<IMachine*>(this) /* aInitiator */,
    4342                            Bstr(tr("Deleting files")),
     4342                           Bstr(tr("Deleting files")).raw(),
    43434343                           true /* fCancellable */,
    43444344                           pTask->llFilesToDelete.size() + 1,   // cOperations
    4345                            BstrFmt(tr("Deleting '%s'"), pTask->llFilesToDelete.front().c_str()));
     4345                           BstrFmt(tr("Deleting '%s'"), pTask->llFilesToDelete.front().c_str()).raw());
    43464346
    43474347    int vrc = RTThreadCreate(NULL,
    … …  
    44274427        if (it == task.llFilesToDelete.end())
    44284428        {
    4429             task.pProgress->SetNextOperation(Bstr(tr("Cleaning up machine directory")), 1);
     4429            task.pProgress->SetNextOperation(Bstr(tr("Cleaning up machine directory")).raw(), 1);
    44304430            break;
    44314431        }
    44324432
    4433         task.pProgress->SetNextOperation(BstrFmt(tr("Deleting '%s'"), it->c_str()), 1);
     4433        task.pProgress->SetNextOperation(BstrFmt(tr("Deleting '%s'"), it->c_str()).raw(), 1);
    44344434    }
    44354435
    … …  
    68236823    // look up the object by Id to check it is valid
    68246824    ComPtr<IGuestOSType> guestOSType;
    6825     HRESULT rc = mParent->GetGuestOSType(Bstr(mUserData->s.strOsType),
     6825    HRESULT rc = mParent->GetGuestOSType(Bstr(mUserData->s.strOsType).raw(),
    68266826                                         guestOSType.asOutParam());
    68276827    if (FAILED(rc)) return rc;
    … …  
    68436843
    68446844    // snapshot folder needs special processing so set it again
    6845     rc = COMSETTER(SnapshotFolder)(Bstr(config.machineUserData.strSnapshotFolder));
     6845    rc = COMSETTER(SnapshotFolder)(Bstr(config.machineUserData.strSnapshotFolder).raw());
    68466846    if (FAILED(rc)) return rc;
    68476847
    … …  
    71647164        {
    71657165            const settings::SharedFolder &sf = *it;
    7166             rc = CreateSharedFolder(Bstr(sf.strName), Bstr(sf.strHostPath), sf.fWritable, sf.fAutoMount);
     7166            rc = CreateSharedFolder(Bstr(sf.strName).raw(),
     7167                                    Bstr(sf.strHostPath).raw(),
     7168                                    sf.fWritable, sf.fAutoMount);
    71677169            if (FAILED(rc)) return rc;
    71687170        }
    … …  
    83068308    MediaData::AttachmentList atts;
    83078309
    8308     HRESULT rc = getMediumAttachmentsOfController(Bstr(aStorageController->getName()), atts);
     8310    HRESULT rc = getMediumAttachmentsOfController(Bstr(aStorageController->getName()).raw(), atts);
    83098311    if (FAILED(rc)) return rc;
    83108312
    … …  
    85318533                {
    85328534                    if (pMedium == NULL)
    8533                         aProgress->SetNextOperation(Bstr(tr("Skipping attachment without medium")),
     8535                        aProgress->SetNextOperation(Bstr(tr("Skipping attachment without medium")).raw(),
    85348536                                                    aWeight);        // weight
    85358537                    else
    85368538                        aProgress->SetNextOperation(BstrFmt(tr("Skipping medium '%s'"),
    8537                                                             pMedium->getBase()->getName().c_str()),
     8539                                                            pMedium->getBase()->getName().c_str()).raw(),
    85388540                                                    aWeight);        // weight
    85398541                }
    … …  
    85458547            /* need a diff */
    85468548            aProgress->SetNextOperation(BstrFmt(tr("Creating differencing hard disk for '%s'"),
    8547                                                 pMedium->getBase()->getName().c_str()),
     8549                                                pMedium->getBase()->getName().c_str()).raw(),
    85488550                                        aWeight);        // weight
    85498551
    … …  
    1045410456        ComPtr<IUnknown> pPeer(mPeer);
    1045510457        progress->init(mParent, pPeer,
    10456                        Bstr(tr("Closing session")),
     10458                       Bstr(tr("Closing session")).raw(),
    1045710459                       FALSE /* aCancelable */);
    1045810460        progress.queryInterfaceTo(aProgress);

  • trunk/src/VBox/Main/MediumImpl.cpp

    r32695 r32718  
    22662266                             static_cast<IMedium*>(this),
    22672267                             (aVariant & MediumVariant_Fixed)
    2268                                ? BstrFmt(tr("Creating fixed medium storage unit '%s'"), m->strLocationFull.c_str())
    2269                                : BstrFmt(tr("Creating dynamic medium storage unit '%s'"), m->strLocationFull.c_str()),
     2268                               ? BstrFmt(tr("Creating fixed medium storage unit '%s'"), m->strLocationFull.c_str()).raw()
     2269                               : BstrFmt(tr("Creating dynamic medium storage unit '%s'"), m->strLocationFull.c_str()).raw(),
    22702270                             TRUE /* aCancelable */);
    22712271        if (FAILED(rc))
    … …  
    24832483        rc = pProgress->init(m->pVirtualBox,
    24842484                             static_cast <IMedium *>(this),
    2485                              BstrFmt(tr("Creating clone medium '%s'"), pTarget->m->strLocationFull.c_str()),
     2485                             BstrFmt(tr("Creating clone medium '%s'"), pTarget->m->strLocationFull.c_str()).raw(),
    24862486                             TRUE /* aCancelable */);
    24872487        if (FAILED(rc))
    … …  
    25622562        rc = pProgress->init(m->pVirtualBox,
    25632563                             static_cast <IMedium *>(this),
    2564                              BstrFmt(tr("Compacting medium '%s'"), m->strLocationFull.c_str()),
     2564                             BstrFmt(tr("Compacting medium '%s'"), m->strLocationFull.c_str()).raw(),
    25652565                             TRUE /* aCancelable */);
    25662566        if (FAILED(rc))
    … …  
    26352635        rc = pProgress->init(m->pVirtualBox,
    26362636                             static_cast <IMedium *>(this),
    2637                              BstrFmt(tr("Compacting medium '%s'"), m->strLocationFull.c_str()),
     2637                             BstrFmt(tr("Compacting medium '%s'"), m->strLocationFull.c_str()).raw(),
    26382638                             TRUE /* aCancelable */);
    26392639        if (FAILED(rc))
    … …  
    27182718        rc = pProgress->init(m->pVirtualBox,
    27192719                             static_cast<IMedium*>(this),
    2720                              BstrFmt(tr("Resetting differencing medium '%s'"), m->strLocationFull.c_str()),
     2720                             BstrFmt(tr("Resetting differencing medium '%s'"), m->strLocationFull.c_str()).raw(),
    27212721                             FALSE /* aCancelable */);
    27222722        if (FAILED(rc))
    … …  
    43414341                rc = pProgress->init(m->pVirtualBox,
    43424342                                     static_cast<IMedium*>(this),
    4343                                      BstrFmt(tr("Deleting medium storage unit '%s'"), m->strLocationFull.c_str()),
     4343                                     BstrFmt(tr("Deleting medium storage unit '%s'"), m->strLocationFull.c_str()).raw(),
    43444344                                     FALSE /* aCancelable */);
    43454345                if (FAILED(rc))
    … …  
    45624562                rc = pProgress->init(m->pVirtualBox,
    45634563                                     static_cast<IMedium*>(this),
    4564                                      BstrFmt(tr("Creating differencing medium storage unit '%s'"), aTarget->m->strLocationFull.c_str()),
     4564                                     BstrFmt(tr("Creating differencing medium storage unit '%s'"), aTarget->m->strLocationFull.c_str()).raw(),
    45654565                                     TRUE /* aCancelable */);
    45664566                if (FAILED(rc))
    … …  
    50225022                                     BstrFmt(tr("Merging medium '%s' to '%s'"),
    50235023                                             getName().c_str(),
    5024                                              tgtName.c_str()),
     5024                                             tgtName.c_str()).raw(),
    50255025                                     TRUE /* aCancelable */);
    50265026                if (FAILED(rc))

  • trunk/src/VBox/Main/NetworkAdapterImpl.cpp

    r31287 r32718  
    332332    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
    333333
    334     ComAssertRet(!!mData->mMACAddress, E_FAIL);
     334    ComAssertRet(!mData->mMACAddress.isEmpty(), E_FAIL);
    335335
    336336    mData->mMACAddress.cloneTo(aMACAddress);
    … …  
    470470    Bstr bstrEmpty("");
    471471    if (!aHostInterface)
    472         aHostInterface = bstrEmpty;
     472        aHostInterface = bstrEmpty.raw();
    473473
    474474    AutoCaller autoCaller(this);
    … …  
    577577    Bstr bstrEmpty("");
    578578    if (!aNATNetwork)
    579         aNATNetwork = bstrEmpty;
     579        aNATNetwork = bstrEmpty.raw();
    580580
    581581    AutoCaller autoCaller(this);
    … …  
    633633    Bstr bstrEmpty("");
    634634    if (!aVDENetwork)
    635         aVDENetwork = bstrEmpty;
     635        aVDENetwork = bstrEmpty.raw();
    636636
    637637    AutoCaller autoCaller(this);
    … …  
    12511251    mData->mEnabled = data.fEnabled;
    12521252    /* MAC address (can be null) */
    1253     rc = COMSETTER(MACAddress)(Bstr(data.strMACAddress));
     1253    rc = COMSETTER(MACAddress)(Bstr(data.strMACAddress).raw());
    12541254    if (FAILED(rc)) return rc;
    12551255    /* cable (required) */
    … …  
    12741274
    12751275        case NetworkAttachmentType_Bridged:
    1276             rc = COMSETTER(HostInterface)(Bstr(data.strName));
     1276            rc = COMSETTER(HostInterface)(Bstr(data.strName).raw());
    12771277            if (FAILED(rc)) return rc;
    12781278            rc = AttachToBridgedInterface();
    … …  
    12901290        case NetworkAttachmentType_HostOnly:
    12911291#if defined(VBOX_WITH_NETFLT)
    1292             rc = COMSETTER(HostInterface)(Bstr(data.strName));
     1292            rc = COMSETTER(HostInterface)(Bstr(data.strName).raw());
    12931293            if (FAILED(rc)) return rc;
    12941294#endif

  • trunk/src/VBox/Main/ProgressProxyImpl.cpp

    r32431 r32718  
    227227        muOtherProgressStartWeight = m_ulOperationsCompletedWeight + m_ulCurrentOperationWeight;
    228228        muOtherProgressWeight      = m_ulTotalOperationsWeight - muOtherProgressStartWeight;
    229         Progress::SetNextOperation(bstrOperationDescription, muOtherProgressWeight);
     229        Progress::SetNextOperation(bstrOperationDescription.raw(), muOtherProgressWeight);
    230230
    231231        muOtherProgressStartOperation = m_ulCurrentOperation;

  • trunk/src/VBox/Main/SharedFolderImpl.cpp

    r31544 r32718  
    105105    unconst(mMachine) = aMachine;
    106106
    107     HRESULT rc = protectedInit (aMachine, aThat->m.name,
    108                                 aThat->m.hostPath, aThat->m.writable, aThat->m.autoMount);
     107    HRESULT rc = protectedInit(aMachine, aThat->m.name.raw(),
     108                               aThat->m.hostPath.raw(), aThat->m.writable,
     109                               aThat->m.autoMount);
    109110
    110111    /* Confirm a successful initialization when it's the case */

  • trunk/src/VBox/Main/SnapshotImpl.cpp

    r31615 r32718  
    14521452                             stateFrom.c_str(), stateTo.c_str()));
    14531453
    1454             aConsoleProgress->SetNextOperation(Bstr(tr("Copying the execution state")),
     1454            aConsoleProgress->SetNextOperation(Bstr(tr("Copying the execution state")).raw(),
    14551455                                               1);        // weight
    14561456
    … …  
    17101710    pProgress.createObject();
    17111711    pProgress->init(mParent, aInitiator,
    1712                     BstrFmt(tr("Restoring snapshot '%s'"), pSnapshot->getName().c_str()),
     1712                    BstrFmt(tr("Restoring snapshot '%s'"), pSnapshot->getName().c_str()).raw(),
    17131713                    FALSE /* aCancelable */,
    17141714                    ulOpCount,
    17151715                    ulTotalWeight,
    1716                     Bstr(tr("Restoring machine settings")),
     1716                    Bstr(tr("Restoring machine settings")).raw(),
    17171717                    1);
    17181718
    … …  
    18651865                                  snapStateFilePath.c_str(), stateFilePath.c_str()));
    18661866
    1867                 aTask.pProgress->SetNextOperation(Bstr(tr("Restoring the execution state")),
     1867                aTask.pProgress->SetNextOperation(Bstr(tr("Restoring the execution state")).raw(),
    18681868                                                  aTask.m_ulStateFileSizeMB);        // weight
    18691869
    … …  
    21592159    pProgress.createObject();
    21602160    pProgress->init(mParent, aInitiator,
    2161                     BstrFmt(tr("Deleting snapshot '%s'"), pSnapshot->getName().c_str()),
     2161                    BstrFmt(tr("Deleting snapshot '%s'"), pSnapshot->getName().c_str()).raw(),
    21622162                    FALSE /* aCancelable */,
    21632163                    ulOpCount,
    21642164                    ulTotalWeight,
    2165                     Bstr(tr("Setting up")),
     2165                    Bstr(tr("Setting up")).raw(),
    21662166                    1);
    21672167
    … …  
    23952395                pOnlineMediumAttachment =
    23962396                    findAttachment(mMediaData->mAttachments,
    2397                                    pAttach->getControllerName(),
     2397                                   pAttach->getControllerName().raw(),
    23982398                                   pAttach->getPort(),
    23992399                                   pAttach->getDevice());
    … …  
    25102510            if (!stateFilePath.isEmpty())
    25112511            {
    2512                 aTask.pProgress->SetNextOperation(Bstr(tr("Deleting the execution state")),
     2512                aTask.pProgress->SetNextOperation(Bstr(tr("Deleting the execution state")).raw(),
    25132513                                                  1);        // weight
    25142514
    … …  
    25362536
    25372537            aTask.pProgress->SetNextOperation(BstrFmt(tr("Merging differencing image '%s'"),
    2538                                               pMedium->getName().c_str()),
     2538                                              pMedium->getName().c_str()).raw(),
    25392539                                              ulWeight);
    25402540

  • trunk/src/VBox/Main/USBDeviceFilterImpl.cpp

    r31892 r32718  
    257257        if (FAILED(rc)) break;
    258258
    259         rc = COMSETTER(Remote)(Bstr(data.strRemote));
     259        rc = COMSETTER(Remote)(Bstr(data.strRemote).raw());
    260260        if (FAILED(rc)) break;
    261261

  • trunk/src/VBox/Main/VFSExplorerImpl.cpp

    r31539 r32718  
    542542        rc = progress->init(mVirtualBox,
    543543                            static_cast<IVFSExplorer*>(this),
    544                             progressDesc,
     544                            progressDesc.raw(),
    545545                            TRUE /* aCancelable */);
    546546        if (FAILED(rc)) throw rc;
    … …  
    671671
    672672        rc = progress->init(mVirtualBox, static_cast<IVFSExplorer*>(this),
    673                             Bstr(tr("Delete files")),
     673                            Bstr(tr("Delete files")).raw(),
    674674                            TRUE /* aCancelable */);
    675675        if (FAILED(rc)) throw rc;

  • trunk/src/VBox/Main/VirtualBoxImpl.cpp

    r32120 r32718  
    16951695        Bstr bstrValue(aValue);
    16961696
    1697         if (!onExtraDataCanChange(Guid::Empty, aKey, bstrValue, error))
     1697        if (!onExtraDataCanChange(Guid::Empty, aKey, bstrValue.raw(), error))
    16981698        {
    16991699            const char *sep = error.isEmpty() ? "" : ": ";
    … …  
    44014401
    44024402    ComPtr<IDHCPServer> existing;
    4403     rc = FindDHCPServerByNetworkName(name, existing.asOutParam());
     4403    rc = FindDHCPServerByNetworkName(name.raw(), existing.asOutParam());
    44044404    if (SUCCEEDED(rc))
    44054405        return E_INVALIDARG;

  • trunk/src/VBox/Main/generic/NetIf-generic.cpp

    r30714 r32718  
    55
    66/*
    7  * Copyright (C) 2009 Oracle Corporation
     7 * Copyright (C) 2009-2010 Oracle Corporation
    88 *
    99 * This file is part of VirtualBox Open Source Edition (OSE), as
    … …  
    127127
    128128
    129 int NetIfCreateHostOnlyNetworkInterface (VirtualBox *pVBox, IHostNetworkInterface **aHostNetworkInterface, IProgress **aProgress)
     129int NetIfCreateHostOnlyNetworkInterface(VirtualBox *pVBox, IHostNetworkInterface **aHostNetworkInterface, IProgress **aProgress)
    130130{
    131131#if defined(RT_OS_LINUX) || defined(RT_OS_DARWIN) || defined(RT_OS_FREEBSD)
    … …  
    139139    {
    140140        hrc = progress->init(pVBox, host,
    141                              Bstr ("Creating host only network interface"),
     141                             Bstr("Creating host only network interface").raw(),
    142142                             FALSE /* aCancelable */);
    143143        if (SUCCEEDED(hrc))
    … …  
    220220}
    221221
    222 int NetIfRemoveHostOnlyNetworkInterface (VirtualBox *pVBox, IN_GUID aId,
    223                                          IProgress **aProgress)
     222int NetIfRemoveHostOnlyNetworkInterface(VirtualBox *pVBox, IN_GUID aId,
     223                                        IProgress **aProgress)
    224224{
    225225#if defined(RT_OS_LINUX) || defined(RT_OS_DARWIN) || defined(RT_OS_FREEBSD)
    … …  
    234234        Bstr ifname;
    235235        ComPtr<IHostNetworkInterface> iface;
    236         if (FAILED(host->FindHostNetworkInterfaceById (Guid(aId).toUtf16(), iface.asOutParam())))
     236        if (FAILED(host->FindHostNetworkInterfaceById(Guid(aId).toUtf16().raw(), iface.asOutParam())))
    237237            return VERR_INVALID_PARAMETER;
    238         iface->COMGETTER(Name) (ifname.asOutParam());
     238        iface->COMGETTER(Name)(ifname.asOutParam());
    239239        if (ifname.isEmpty())
    240240            return VERR_INTERNAL_ERROR;
    241241
    242         rc = progress->init (pVBox, host,
    243                             Bstr ("Removing host network interface"),
     242        rc = progress->init(pVBox, host,
     243                            Bstr("Removing host network interface").raw(),
    244244                            FALSE /* aCancelable */);
    245245        if(SUCCEEDED(rc))

  • trunk/src/VBox/Main/glue/ErrorInfo.cpp

    r30739 r32718  
    77
    88/*
    9  * Copyright (C) 2006-2007 Oracle Corporation
     9 * Copyright (C) 2006-2010 Oracle Corporation
    1010 *
    1111 * This file is part of VirtualBox Open Source Edition (OSE), as
    … …  
    1818 */
    1919
    20 #if !defined (VBOX_WITH_XPCOM)
    21 #else
    22  #include <nsIServiceManager.h>
    23  #include <nsIExceptionService.h>
    24  #include <nsCOMPtr.h>
     20#if defined(VBOX_WITH_XPCOM)
     21# include <nsIServiceManager.h>
     22# include <nsIExceptionService.h>
     23# include <nsCOMPtr.h>
    2524#endif
    2625
    … …  
    9291    HRESULT rc = E_FAIL;
    9392
    94 #if !defined (VBOX_WITH_XPCOM)
     93#if !defined(VBOX_WITH_XPCOM)
    9594
    9695    ComPtr<IErrorInfo> err;
    97     rc = ::GetErrorInfo (0, err.asOutParam());
     96    rc = ::GetErrorInfo(0, err.asOutParam());
    9897    if (rc == S_OK && err)
    9998    {
    … …  
    104103        rc = err.queryInterfaceTo(info.asOutParam());
    105104        if (SUCCEEDED(rc) && info)
    106             init (info);
     105            init(info);
    107106
    108107        if (!mIsFullAvailable)
    … …  
    110109            bool gotSomething = false;
    111110
    112             rc = err->GetGUID (mInterfaceID.asOutParam());
     111            rc = err->GetGUID(mInterfaceID.asOutParam());
    113112            gotSomething |= SUCCEEDED(rc);
    114113            if (SUCCEEDED(rc))
    115                 GetInterfaceNameByIID (mInterfaceID, mInterfaceName.asOutParam());
    116 
    117             rc = err->GetSource (mComponent.asOutParam());
     114                GetInterfaceNameByIID(mInterfaceID, mInterfaceName.asOutParam());
     115
     116            rc = err->GetSource(mComponent.asOutParam());
    118117            gotSomething |= SUCCEEDED(rc);
    119118
    120             rc = err->GetDescription (mText.asOutParam());
     119            rc = err->GetDescription(mText.asOutParam());
    121120            gotSomething |= SUCCEEDED(rc);
    122121
    … …  
    124123                mIsBasicAvailable = true;
    125124
    126             AssertMsg (gotSomething, ("Nothing to fetch!\n"));
     125            AssertMsg(gotSomething, ("Nothing to fetch!\n"));
    127126        }
    128127    }
    129128
    130 #else // defined (VBOX_WITH_XPCOM)
     129#else // defined(VBOX_WITH_XPCOM)
    131130
    132131    nsCOMPtr<nsIExceptionService> es;
    … …  
    135134    {
    136135        nsCOMPtr<nsIExceptionManager> em;
    137         rc = es->GetCurrentExceptionManager(getter_AddRefs (em));
     136        rc = es->GetCurrentExceptionManager(getter_AddRefs(em));
    138137        if (NS_SUCCEEDED(rc))
    139138        {
    … …  
    148147                rc = ex.queryInterfaceTo(info.asOutParam());
    149148                if (NS_SUCCEEDED(rc) && info)
    150                     init (info);
     149                    init(info);
    151150
    152151                if (!mIsFullAvailable)
    … …  
    163162                    {
    164163                        mText = Bstr(pszMsg);
    165                         nsMemory::Free(mText);
     164                        nsMemory::Free(pszMsg);
    166165                    }
    167166
    … …  
    169168                        mIsBasicAvailable = true;
    170169
    171                     AssertMsg (gotSomething, ("Nothing to fetch!\n"));
     170                    AssertMsg(gotSomething, ("Nothing to fetch!\n"));
    172171                }
    173172
    174173                // set the exception to NULL (to emulate Win32 behavior)
    175                 em->SetCurrentException (NULL);
     174                em->SetCurrentException(NULL);
    176175
    177176                rc = NS_OK;
    … …  
    183182        rc = NS_OK;
    184183
    185     AssertComRC (rc);
    186 
    187 #endif // defined (VBOX_WITH_XPCOM)
     184    AssertComRC(rc);
     185
     186#endif // defined(VBOX_WITH_XPCOM)
    188187}
    189188
    … …  
    196195        return;
    197196
    198 #if !defined (VBOX_WITH_XPCOM)
     197#if !defined(VBOX_WITH_XPCOM)
    199198
    200199    ComPtr<IUnknown> iface = aI;
    … …  
    203202    if (SUCCEEDED(rc))
    204203    {
    205         rc = serr->InterfaceSupportsErrorInfo (aIID);
     204        rc = serr->InterfaceSupportsErrorInfo(aIID);
    206205        if (SUCCEEDED(rc))
    207             init (aKeepObj);
     206            init(aKeepObj);
    208207    }
    209208
    210209#else
    211210
    212     init (aKeepObj);
     211    init(aKeepObj);
    213212
    214213#endif
    … …  
    217216    {
    218217        mCalleeIID = aIID;
    219         GetInterfaceNameByIID (aIID, mCalleeName.asOutParam());
     218        GetInterfaceNameByIID(aIID, mCalleeName.asOutParam());
    220219    }
    221220}
    … …  
    223222void ErrorInfo::init(IVirtualBoxErrorInfo *info)
    224223{
    225     AssertReturnVoid (info);
     224    AssertReturnVoid(info);
    226225
    227226    HRESULT rc = E_FAIL;
    … …  
    230229    LONG lrc;
    231230
    232     rc = info->COMGETTER(ResultCode) (&lrc); mResultCode = lrc;
     231    rc = info->COMGETTER(ResultCode)(&lrc); mResultCode = lrc;
    233232    gotSomething |= SUCCEEDED(rc);
    234233    gotAll &= SUCCEEDED(rc);
    235234
    236235    Bstr iid;
    237     rc = info->COMGETTER(InterfaceID) (iid.asOutParam());
     236    rc = info->COMGETTER(InterfaceID)(iid.asOutParam());
    238237    gotSomething |= SUCCEEDED(rc);
    239238    gotAll &= SUCCEEDED(rc);
    … …  
    241240    {
    242241        mInterfaceID = iid;
    243         GetInterfaceNameByIID (mInterfaceID, mInterfaceName.asOutParam());
    244     }
    245 
    246     rc = info->COMGETTER(Component) (mComponent.asOutParam());
    247     gotSomething |= SUCCEEDED(rc);
    248     gotAll &= SUCCEEDED(rc);
    249 
    250     rc = info->COMGETTER(Text) (mText.asOutParam());
     242        GetInterfaceNameByIID(mInterfaceID, mInterfaceName.asOutParam());
     243    }
     244
     245    rc = info->COMGETTER(Component)(mComponent.asOutParam());
     246    gotSomething |= SUCCEEDED(rc);
     247    gotAll &= SUCCEEDED(rc);
     248
     249    rc = info->COMGETTER(Text)(mText.asOutParam());
    251250    gotSomething |= SUCCEEDED(rc);
    252251    gotAll &= SUCCEEDED(rc);
    … …  
    255254
    256255    ComPtr<IVirtualBoxErrorInfo> next;
    257     rc = info->COMGETTER(Next) (next.asOutParam());
     256    rc = info->COMGETTER(Next)(next.asOutParam());
    258257    if (SUCCEEDED(rc) && !next.isNull())
    259258    {
    … …  
    270269    mIsFullAvailable = gotAll;
    271270
    272     AssertMsg (gotSomething, ("Nothing to fetch!\n"));
     271    AssertMsg(gotSomething, ("Nothing to fetch!\n"));
    273272}
    274273
    … …  
    279278////////////////////////////////////////////////////////////////////////////////
    280279
    281 ProgressErrorInfo::ProgressErrorInfo (IProgress *progress) :
    282     ErrorInfo (false /* aDummy */)
     280ProgressErrorInfo::ProgressErrorInfo(IProgress *progress) :
     281    ErrorInfo(false /* aDummy */)
    283282{
    284283    Assert(progress);
    … …  
    287286
    288287    ComPtr<IVirtualBoxErrorInfo> info;
    289     HRESULT rc = progress->COMGETTER(ErrorInfo) (info.asOutParam());
     288    HRESULT rc = progress->COMGETTER(ErrorInfo)(info.asOutParam());
    290289    if (SUCCEEDED(rc) && info)
    291         init (info);
     290        init(info);
    292291}
    293292
    … …  
    305304    HRESULT rc = S_OK;
    306305
    307 #if !defined (VBOX_WITH_XPCOM)
     306#if !defined(VBOX_WITH_XPCOM)
    308307
    309308    ComPtr<IErrorInfo> err;
    … …  
    311310    {
    312311        rc = mErrorInfo.queryInterfaceTo(err.asOutParam());
    313         AssertComRC (rc);
    314     }
    315     rc = ::SetErrorInfo (0, err);
    316 
    317 #else // !defined (VBOX_WITH_XPCOM)
     312        AssertComRC(rc);
     313    }
     314    rc = ::SetErrorInfo(0, err);
     315
     316#else // !defined(VBOX_WITH_XPCOM)
    318317
    319318    nsCOMPtr <nsIExceptionService> es;
    320     es = do_GetService (NS_EXCEPTIONSERVICE_CONTRACTID, &rc);
     319    es = do_GetService(NS_EXCEPTIONSERVICE_CONTRACTID, &rc);
    321320    if (NS_SUCCEEDED(rc))
    322321    {
    323322        nsCOMPtr <nsIExceptionManager> em;
    324         rc = es->GetCurrentExceptionManager (getter_AddRefs (em));
     323        rc = es->GetCurrentExceptionManager(getter_AddRefs(em));
    325324        if (NS_SUCCEEDED(rc))
    326325        {
    … …  
    329328            {
    330329                rc = mErrorInfo.queryInterfaceTo(ex.asOutParam());
    331                 AssertComRC (rc);
     330                AssertComRC(rc);
    332331            }
    333             rc = em->SetCurrentException (ex);
     332            rc = em->SetCurrentException(ex);
    334333        }
    335334    }
    336335
    337 #endif // !defined (VBOX_WITH_XPCOM)
     336#endif // !defined(VBOX_WITH_XPCOM)
    338337
    339338    if (SUCCEEDED(rc))

  • trunk/src/VBox/Main/glue/errorprint.cpp

    r30764 r32718  
    77
    88/*
    9  * Copyright (C) 2009 Oracle Corporation
     9 * Copyright (C) 2009-2010 Oracle Corporation
    1010 *
    1111 * This file is part of VirtualBox Open Source Edition (OSE), as
    … …  
    2424
    2525#include <iprt/stream.h>
     26#include <iprt/message.h>
    2627#include <iprt/path.h>
    2728
    … …  
    3132void GluePrintErrorInfo(com::ErrorInfo &info)
    3233{
    33     Utf8Str str = Utf8StrFmt("ERROR: %ls\n"
     34    Utf8Str str = Utf8StrFmt("%ls\n"
    3435                             "Details: code %Rhrc (0x%RX32), component %ls, interface %ls, callee %ls\n"
    3536                             ,
    … …  
    4142                             info.getCalleeName().raw());
    4243    // print and log
    43     RTPrintf("%s", str.c_str());
    44     Log(("%s", str.c_str()));
     44    RTMsgError("%s", str.c_str());
     45    Log(("ERROR: %s", str.c_str()));
    4546}
    4647
    … …  
    5556                                strFilename.c_str());
    5657    // print and log
    57     RTPrintf("%s", str.c_str());
     58    RTStrmPrintf(g_pStdErr, "%s", str.c_str());
    5859    Log(("%s", str.c_str()));
    5960}
    … …  
    6162void GluePrintRCMessage(HRESULT rc)
    6263{
    63     Utf8Str str = Utf8StrFmt("ERROR: code %Rhra (extended info not available)\n", rc);
     64    Utf8Str str = Utf8StrFmt("Code %Rhra (extended info not available)\n", rc);
    6465    // print and log
    65     RTPrintf("%s", str.c_str());
    66     Log(("%s", str.c_str()));
     66    RTMsgError("%s", str.c_str());
     67    Log(("ERROR: %s", str.c_str()));
    6768}
    6869

  • trunk/src/VBox/Main/testcase/tstAPI.cpp

    r28800 r32718  
    4848static Bstr getObjectName(ComPtr<IVirtualBox> aVirtualBox,
    4949                                  ComPtr<IUnknown> aObject);
    50 static void queryMetrics (ComPtr<IVirtualBox> aVirtualBox,
    51                           ComPtr<IPerformanceCollector> collector,
    52                           ComSafeArrayIn (IUnknown *, objects));
     50static void queryMetrics(ComPtr<IVirtualBox> aVirtualBox,
     51                         ComPtr<IPerformanceCollector> collector,
     52                         ComSafeArrayIn(IUnknown *, objects));
    5353static void listAffectedMetrics(ComPtr<IVirtualBox> aVirtualBox,
    5454                                ComSafeArrayIn(IPerformanceMetric*, aMetrics));
    … …  
    5757///////////////////////////////////////////////////////////////////////////////
    5858
    59 HRESULT readAndChangeMachineSettings (IMachine *machine, IMachine *readonlyMachine = 0)
     59HRESULT readAndChangeMachineSettings(IMachine *machine, IMachine *readonlyMachine = 0)
    6060{
    6161    HRESULT rc = S_OK;
    6262
    6363    Bstr name;
    64     RTPrintf ("Getting machine name...\n");
    65     CHECK_ERROR_RET (machine, COMGETTER(Name) (name.asOutParam()), rc);
    66     RTPrintf ("Name: {%ls}\n", name.raw());
     64    RTPrintf("Getting machine name...\n");
     65    CHECK_ERROR_RET(machine, COMGETTER(Name)(name.asOutParam()), rc);
     66    RTPrintf("Name: {%ls}\n", name.raw());
    6767
    6868    RTPrintf("Getting machine GUID...\n");
    6969    Bstr guid;
    70     CHECK_ERROR (machine, COMGETTER(Id) (guid.asOutParam()));
     70    CHECK_ERROR(machine, COMGETTER(Id)(guid.asOutParam()));
    7171    if (SUCCEEDED(rc) && !guid.isEmpty()) {
    72         RTPrintf ("Guid::toString(): {%s}\n", Utf8Str(guid).c_str());
     72        RTPrintf("Guid::toString(): {%s}\n", Utf8Str(guid).c_str());
    7373    } else {
    74         RTPrintf ("WARNING: there's no GUID!");
     74        RTPrintf("WARNING: there's no GUID!");
    7575    }
    7676
    7777    ULONG memorySize;
    78     RTPrintf ("Getting memory size...\n");
    79     CHECK_ERROR_RET (machine, COMGETTER(MemorySize) (&memorySize), rc);
    80     RTPrintf ("Memory size: %d\n", memorySize);
     78    RTPrintf("Getting memory size...\n");
     79    CHECK_ERROR_RET(machine, COMGETTER(MemorySize)(&memorySize), rc);
     80    RTPrintf("Memory size: %d\n", memorySize);
    8181
    8282    MachineState_T machineState;
    83     RTPrintf ("Getting machine state...\n");
    84     CHECK_ERROR_RET (machine, COMGETTER(State) (&machineState), rc);
    85     RTPrintf ("Machine state: %d\n", machineState);
     83    RTPrintf("Getting machine state...\n");
     84    CHECK_ERROR_RET(machine, COMGETTER(State)(&machineState), rc);
     85    RTPrintf("Machine state: %d\n", machineState);
    8686
    8787    BOOL modified;
    88     RTPrintf ("Are any settings modified?...\n");
    89     CHECK_ERROR (machine, COMGETTER(SettingsModified) (&modified));
     88    RTPrintf("Are any settings modified?...\n");
     89    CHECK_ERROR(machine, COMGETTER(SettingsModified)(&modified));
    9090    if (SUCCEEDED(rc))
    91         RTPrintf ("%s\n", modified ? "yes" : "no");
     91        RTPrintf("%s\n", modified ? "yes" : "no");
    9292
    9393    ULONG memorySizeBig = memorySize * 10;
    9494    RTPrintf("Changing memory size to %d...\n", memorySizeBig);
    95     CHECK_ERROR (machine, COMSETTER(MemorySize) (memorySizeBig));
     95    CHECK_ERROR(machine, COMSETTER(MemorySize)(memorySizeBig));
    9696
    9797    if (SUCCEEDED(rc))
    9898    {
    99         RTPrintf ("Are any settings modified now?...\n");
    100         CHECK_ERROR_RET (machine, COMGETTER(SettingsModified) (&modified), rc);
    101         RTPrintf ("%s\n", modified ? "yes" : "no");
    102         ASSERT_RET (modified, 0);
     99        RTPrintf("Are any settings modified now?...\n");
     100        CHECK_ERROR_RET(machine, COMGETTER(SettingsModified)(&modified), rc);
     101        RTPrintf("%s\n", modified ? "yes" : "no");
     102        ASSERT_RET(modified, 0);
    103103
    104104        ULONG memorySizeGot;
    105         RTPrintf ("Getting memory size again...\n");
    106         CHECK_ERROR_RET (machine, COMGETTER(MemorySize) (&memorySizeGot), rc);
    107         RTPrintf ("Memory size: %d\n", memorySizeGot);
    108         ASSERT_RET (memorySizeGot == memorySizeBig, 0);
     105        RTPrintf("Getting memory size again...\n");
     106        CHECK_ERROR_RET(machine, COMGETTER(MemorySize)(&memorySizeGot), rc);
     107        RTPrintf("Memory size: %d\n", memorySizeGot);
     108        ASSERT_RET(memorySizeGot == memorySizeBig, 0);
    109109
    110110        if (readonlyMachine)
    111111        {
    112             RTPrintf ("Getting memory size of the counterpart readonly machine...\n");
     112            RTPrintf("Getting memory size of the counterpart readonly machine...\n");
    113113            ULONG memorySizeRO;
    114             readonlyMachine->COMGETTER(MemorySize) (&memorySizeRO);
    115             RTPrintf ("Memory size: %d\n", memorySizeRO);
    116             ASSERT_RET (memorySizeRO != memorySizeGot, 0);
    117         }
    118 
    119         RTPrintf ("Discarding recent changes...\n");
    120         CHECK_ERROR_RET (machine, DiscardSettings(), rc);
    121         RTPrintf ("Are any settings modified after discarding?...\n");
    122         CHECK_ERROR_RET (machine, COMGETTER(SettingsModified) (&modified), rc);
    123         RTPrintf ("%s\n", modified ? "yes" : "no");
    124         ASSERT_RET (!modified, 0);
    125 
    126         RTPrintf ("Getting memory size once more...\n");
    127         CHECK_ERROR_RET (machine, COMGETTER(MemorySize) (&memorySizeGot), rc);
    128         RTPrintf ("Memory size: %d\n", memorySizeGot);
    129         ASSERT_RET (memorySizeGot == memorySize, 0);
     114            readonlyMachine->COMGETTER(MemorySize)(&memorySizeRO);
     115            RTPrintf("Memory size: %d\n", memorySizeRO);
     116            ASSERT_RET(memorySizeRO != memorySizeGot, 0);
     117        }
     118
     119        RTPrintf("Discarding recent changes...\n");
     120        CHECK_ERROR_RET(machine, DiscardSettings(), rc);
     121        RTPrintf("Are any settings modified after discarding?...\n");
     122        CHECK_ERROR_RET(machine, COMGETTER(SettingsModified)(&modified), rc);
     123        RTPrintf("%s\n", modified ? "yes" : "no");
     124        ASSERT_RET(!modified, 0);
     125
     126        RTPrintf("Getting memory size once more...\n");
     127        CHECK_ERROR_RET(machine, COMGETTER(MemorySize)(&memorySizeGot), rc);
     128        RTPrintf("Memory size: %d\n", memorySizeGot);
     129        ASSERT_RET(memorySizeGot == memorySize, 0);
    130130
    131131        memorySize = memorySize > 128 ? memorySize / 2 : memorySize * 2;
    132132        RTPrintf("Changing memory size to %d...\n", memorySize);
    133         CHECK_ERROR_RET (machine, COMSETTER(MemorySize) (memorySize), rc);
     133        CHECK_ERROR_RET(machine, COMSETTER(MemorySize)(memorySize), rc);
    134134    }
    135135
    136136    Bstr desc;
    137     RTPrintf ("Getting description...\n");
    138     CHECK_ERROR_RET (machine, COMGETTER(Description) (desc.asOutParam()), rc);
    139     RTPrintf ("Description is: \"%ls\"\n", desc.raw());
     137    RTPrintf("Getting description...\n");
     138    CHECK_ERROR_RET(machine, COMGETTER(Description)(desc.asOutParam()), rc);
     139    RTPrintf("Description is: \"%ls\"\n", desc.raw());
    140140
    141141    desc = L"This is an exemplary description (changed).";
    142     RTPrintf ("Setting description to \"%ls\"...\n", desc.raw());
    143     CHECK_ERROR_RET (machine, COMSETTER(Description) (desc), rc);
    144 
    145     RTPrintf ("Saving machine settings...\n");
    146     CHECK_ERROR (machine, SaveSettings());
     142    RTPrintf("Setting description to \"%ls\"...\n", desc.raw());
     143    CHECK_ERROR_RET(machine, COMSETTER(Description)(desc.raw()), rc);
     144
     145    RTPrintf("Saving machine settings...\n");
     146    CHECK_ERROR(machine, SaveSettings());
    147147    if (SUCCEEDED(rc))
    148148    {
    149         RTPrintf ("Are any settings modified after saving?...\n");
    150         CHECK_ERROR_RET (machine, COMGETTER(SettingsModified) (&modified), rc);
    151         RTPrintf ("%s\n", modified ? "yes" : "no");
    152         ASSERT_RET (!modified, 0);
     149        RTPrintf("Are any settings modified after saving?...\n");
     150        CHECK_ERROR_RET(machine, COMGETTER(SettingsModified)(&modified), rc);
     151        RTPrintf("%s\n", modified ? "yes" : "no");
     152        ASSERT_RET(!modified, 0);
    153153
    154154        if (readonlyMachine) {
    155             RTPrintf ("Getting memory size of the counterpart readonly machine...\n");
     155            RTPrintf("Getting memory size of the counterpart readonly machine...\n");
    156156            ULONG memorySizeRO;
    157             readonlyMachine->COMGETTER(MemorySize) (&memorySizeRO);
    158             RTPrintf ("Memory size: %d\n", memorySizeRO);
    159             ASSERT_RET (memorySizeRO == memorySize, 0);
     157            readonlyMachine->COMGETTER(MemorySize)(&memorySizeRO);
     158            RTPrintf("Memory size: %d\n", memorySizeRO);
     159            ASSERT_RET(memorySizeRO == memorySize, 0);
    160160        }
    161161    }
    … …  
    163163    Bstr extraDataKey = L"Blafasel";
    164164    Bstr extraData;
    165     RTPrintf ("Getting extra data key {%ls}...\n", extraDataKey.raw());
    166     CHECK_ERROR_RET (machine, GetExtraData (extraDataKey, extraData.asOutParam()), rc);
     165    RTPrintf("Getting extra data key {%ls}...\n", extraDataKey.raw());
     166    CHECK_ERROR_RET(machine, GetExtraData(extraDataKey.raw(), extraData.asOutParam()), rc);
    167167    if (!extraData.isEmpty()) {
    168         RTPrintf ("Extra data value: {%ls}\n", extraData.raw());
     168        RTPrintf("Extra data value: {%ls}\n", extraData.raw());
    169169    } else {
    170         RTPrintf ("No extra data exists\n");
     170        RTPrintf("No extra data exists\n");
    171171    }
    172172
    … …  
    175175    else
    176176        extraData.setNull();
    177     RTPrintf (
    178         "Setting extra data key {%ls} to {%ls}...\n",
    179         extraDataKey.raw(), extraData.raw()
    180     );
    181     CHECK_ERROR (machine, SetExtraData (extraDataKey, extraData));
     177    RTPrintf("Setting extra data key {%ls} to {%ls}...\n",
     178             extraDataKey.raw(), extraData.raw());
     179    CHECK_ERROR(machine, SetExtraData(extraDataKey.raw(), extraData.raw()));
    182180
    183181    if (SUCCEEDED(rc)) {
    184         RTPrintf ("Getting extra data key {%ls} again...\n", extraDataKey.raw());
    185         CHECK_ERROR_RET (machine, GetExtraData (extraDataKey, extraData.asOutParam()), rc);
     182        RTPrintf("Getting extra data key {%ls} again...\n", extraDataKey.raw());
     183        CHECK_ERROR_RET(machine, GetExtraData(extraDataKey.raw(), extraData.asOutParam()), rc);
    186184        if (!extraData.isEmpty()) {
    187             RTPrintf ("Extra data value: {%ls}\n", extraData.raw());
     185            RTPrintf("Extra data value: {%ls}\n", extraData.raw());
    188186        } else {
    189             RTPrintf ("No extra data exists\n");
     187            RTPrintf("No extra data exists\n");
    190188        }
    191189    }
    … …  
    208206
    209207    {
    210         char homeDir [RTPATH_MAX];
    211         GetVBoxUserHomeDirectory (homeDir, sizeof (homeDir));
    212         RTPrintf ("VirtualBox Home Directory = '%s'\n", homeDir);
    213     }
    214 
    215     RTPrintf ("Initializing COM...\n");
     208        char homeDir[RTPATH_MAX];
     209        GetVBoxUserHomeDirectory(homeDir, sizeof(homeDir));
     210        RTPrintf("VirtualBox Home Directory = '%s'\n", homeDir);
     211    }
     212
     213    RTPrintf("Initializing COM...\n");
    216214
    217215    rc = com::Initialize();
    … …  
    235233
    236234    Utf8Str nullUtf8Str;
    237     RTPrintf ("nullUtf8Str='%s'\n", nullUtf8Str.raw());
     235    RTPrintf("nullUtf8Str='%s'\n", nullUtf8Str.raw());
    238236
    239237    Utf8Str simpleUtf8Str = "simpleUtf8Str";
    240     RTPrintf ("simpleUtf8Str='%s'\n", simpleUtf8Str.raw());
    241 
    242     Utf8Str utf8StrFmt = Utf8StrFmt ("[0=%d]%s[1=%d]",
    243                                      0, "utf8StrFmt", 1);
    244     RTPrintf ("utf8StrFmt='%s'\n", utf8StrFmt.raw());
    245 
    246 #endif
    247 
    248     RTPrintf ("Creating VirtualBox object...\n");
    249     rc = virtualBox.createLocalObject (CLSID_VirtualBox);
     238    RTPrintf("simpleUtf8Str='%s'\n", simpleUtf8Str.raw());
     239
     240    Utf8Str utf8StrFmt = Utf8StrFmt("[0=%d]%s[1=%d]", 0, "utf8StrFmt", 1);
     241    RTPrintf("utf8StrFmt='%s'\n", utf8StrFmt.raw());
     242
     243#endif
     244
     245    RTPrintf("Creating VirtualBox object...\n");
     246    rc = virtualBox.createLocalObject(CLSID_VirtualBox);
    250247    if (FAILED(rc))
    251248        RTPrintf("ERROR: failed to create the VirtualBox object!\n");
    … …  
    257254    }
    258255
    259     if (FAILED (rc))
     256    if (FAILED(rc))
    260257    {
    261258        com::ErrorInfo info;
    … …  
    277274    ////////////////////////////////////////////////////////////////////////////
    278275    {
    279         RTPrintf ("Testing VirtualBox::COMGETTER(ProgressOperations)...\n");
     276        RTPrintf("Testing VirtualBox::COMGETTER(ProgressOperations)...\n");
    280277
    281278        for (;;) {
    282279            com::SafeIfaceArray<IProgress> operations;
    283280
    284             CHECK_ERROR_BREAK (virtualBox,
     281            CHECK_ERROR_BREAK(virtualBox,
    285282                COMGETTER(ProgressOperations)(ComSafeArrayAsOutParam(operations)));
    286283
    287             RTPrintf ("operations: %d\n", operations.size());
     284            RTPrintf("operations: %d\n", operations.size());
    288285            if (operations.size() == 0)
    289286                break; // No more operations left.
    … …  
    293290
    294291                operations[i]->COMGETTER(Percent)(&percent);
    295                 RTPrintf ("operations[%u]: %ld\n", (unsigned)i, (long)percent);
     292                RTPrintf("operations[%u]: %ld\n", (unsigned)i, (long)percent);
    296293            }
    297             RTThreadSleep (2000); // msec
     294            RTThreadSleep(2000); // msec
    298295        }
    299296    }
    … …  
    307304            ComPtr<IVirtualBox> virtualBox2;
    308305
    309             RTPrintf ("Creating one more VirtualBox object...\n");
    310             CHECK_RC (virtualBox2.createLocalObject (CLSID_VirtualBox));
    311             if (FAILED (rc))
     306            RTPrintf("Creating one more VirtualBox object...\n");
     307            CHECK_RC(virtualBox2.createLocalObject(CLSID_VirtualBox));
     308            if (FAILED(rc))
    312309            {
    313310                CHECK_ERROR_NOCALL();
    … …  
    315312            }
    316313
    317             RTPrintf ("IVirtualBox(virtualBox)=%p IVirtualBox(virtualBox2)=%p\n",
    318                     (IVirtualBox *) virtualBox, (IVirtualBox *) virtualBox2);
    319             Assert ((IVirtualBox *) virtualBox == (IVirtualBox *) virtualBox2);
    320 
    321             ComPtr<IUnknown> unk (virtualBox);
     314            RTPrintf("IVirtualBox(virtualBox)=%p IVirtualBox(virtualBox2)=%p\n",
     315                     (IVirtualBox *)virtualBox, (IVirtualBox *)virtualBox2);
     316            Assert((IVirtualBox *)virtualBox == (IVirtualBox *)virtualBox2);
     317
     318            ComPtr<IUnknown> unk(virtualBox);
    322319            ComPtr<IUnknown> unk2;
    323320            unk2 = virtualBox2;
    324321
    325             RTPrintf ("IUnknown(virtualBox)=%p IUnknown(virtualBox2)=%p\n",
    326                     (IUnknown *) unk, (IUnknown *) unk2);
    327             Assert ((IUnknown *) unk == (IUnknown *) unk2);
     322            RTPrintf("IUnknown(virtualBox)=%p IUnknown(virtualBox2)=%p\n",
     323                     (IUnknown *)unk, (IUnknown *)unk2);
     324            Assert((IUnknown *)unk == (IUnknown *)unk2);
    328325
    329326            ComPtr<IVirtualBox> vb = unk;
    330327            ComPtr<IVirtualBox> vb2 = unk;
    331328
    332             RTPrintf ("IVirtualBox(IUnknown(virtualBox))=%p IVirtualBox(IUnknown(virtualBox2))=%p\n",
    333                     (IVirtualBox *) vb, (IVirtualBox *) vb2);
    334             Assert ((IVirtualBox *) vb == (IVirtualBox *) vb2);
     329            RTPrintf("IVirtualBox(IUnknown(virtualBox))=%p IVirtualBox(IUnknown(virtualBox2))=%p\n",
     330                    (IVirtualBox *)vb, (IVirtualBox *)vb2);
     331            Assert((IVirtualBox *)vb == (IVirtualBox *)vb2);
    335332        }
    336333
    337334        {
    338335            ComPtr<IHost> host;
    339             CHECK_ERROR_BREAK (virtualBox, COMGETTER(Host)(host.asOutParam()));
    340             RTPrintf (" IHost(host)=%p\n", (IHost *) host);
     336            CHECK_ERROR_BREAK(virtualBox, COMGETTER(Host)(host.asOutParam()));
     337            RTPrintf(" IHost(host)=%p\n", (IHost *)host);
    341338            ComPtr<IUnknown> unk = host;
    342             RTPrintf (" IUnknown(host)=%p\n", (IUnknown *) unk);
     339            RTPrintf(" IUnknown(host)=%p\n", (IUnknown *)unk);
    343340            ComPtr<IHost> host_copy = unk;
    344             RTPrintf (" IHost(host_copy)=%p\n", (IHost *) host_copy);
     341            RTPrintf(" IHost(host_copy)=%p\n", (IHost *)host_copy);
    345342            ComPtr<IUnknown> unk_copy = host_copy;
    346             RTPrintf (" IUnknown(host_copy)=%p\n", (IUnknown *) unk_copy);
    347             Assert ((IUnknown *) unk == (IUnknown *) unk_copy);
     343            RTPrintf(" IUnknown(host_copy)=%p\n", (IUnknown *)unk_copy);
     344            Assert((IUnknown *)unk == (IUnknown *)unk_copy);
    348345
    349346            /* query IUnknown on IUnknown */
    350347            ComPtr<IUnknown> unk_copy_copy;
    351348            unk_copy.queryInterfaceTo(unk_copy_copy.asOutParam());
    352             RTPrintf (" IUnknown(unk_copy)=%p\n", (IUnknown *) unk_copy_copy);
    353             Assert ((IUnknown *) unk_copy == (IUnknown *) unk_copy_copy);
     349            RTPrintf(" IUnknown(unk_copy)=%p\n", (IUnknown *)unk_copy_copy);
     350            Assert((IUnknown *)unk_copy == (IUnknown *)unk_copy_copy);
    354351            /* query IUnknown on IUnknown in the opposite direction */
    355352            unk_copy_copy.queryInterfaceTo(unk_copy.asOutParam());
    356             RTPrintf (" IUnknown(unk_copy_copy)=%p\n", (IUnknown *) unk_copy);
    357             Assert ((IUnknown *) unk_copy == (IUnknown *) unk_copy_copy);
     353            RTPrintf(" IUnknown(unk_copy_copy)=%p\n", (IUnknown *)unk_copy);
     354            Assert((IUnknown *)unk_copy == (IUnknown *)unk_copy_copy);
    358355
    359356            /* query IUnknown again after releasing all previous IUnknown instances
    … …  
    364361            unk_copy_copy.setNull();
    365362            unk = host;
    366             RTPrintf (" IUnknown(host)=%p\n", (IUnknown *) unk);
    367             Assert (oldUnk == (IUnknown *) unk);
    368         }
    369 
    370 //        RTPrintf ("Will be now released (press Enter)...");
     363            RTPrintf(" IUnknown(host)=%p\n", (IUnknown *)unk);
     364            Assert(oldUnk == (IUnknown *)unk);
     365        }
     366
     367//        RTPrintf("Will be now released (press Enter)...");
    371368//        getchar();
    372369    }
    … …  
    383380    {
    384381        Bstr version;
    385         CHECK_ERROR_BREAK (virtualBox, COMGETTER(Version) (version.asOutParam()));
    386         RTPrintf ("VirtualBox version = %ls\n", version.raw());
     382        CHECK_ERROR_BREAK(virtualBox, COMGETTER(Version)(version.asOutParam()));
     383        RTPrintf("VirtualBox version = %ls\n", version.raw());
    387384    }
    388385#endif
    … …  
    392389    ////////////////////////////////////////////////////////////////////////////
    393390    {
    394         RTPrintf ("Calling IVirtualBox::Machines...\n");
     391        RTPrintf("Calling IVirtualBox::Machines...\n");
    395392
    396393        com::SafeIfaceArray<IMachine> machines;
    397         CHECK_ERROR_BREAK (virtualBox,
    398                            COMGETTER(Machines) (ComSafeArrayAsOutParam (machines)));
    399 
    400         RTPrintf ("%u machines registered (machines.isNull()=%d).\n",
     394        CHECK_ERROR_BREAK(virtualBox,
     395                          COMGETTER(Machines)(ComSafeArrayAsOutParam(machines)));
     396
     397        RTPrintf("%u machines registered (machines.isNull()=%d).\n",
    401398                machines.size(), machines.isNull());
    402399
    … …  
    404401        {
    405402            Bstr name;
    406             CHECK_ERROR_BREAK (machines [i], COMGETTER(Name) (name.asOutParam()));
    407             RTPrintf ("machines[%u]='%s'\n", i, Utf8Str (name).raw());
    408         }
    409 
    410 #if 0
    411         {
    412             RTPrintf ("Testing [out] arrays...\n");
     403            CHECK_ERROR_BREAK(machines[i], COMGETTER(Name)(name.asOutParam()));
     404            RTPrintf("machines[%u]='%s'\n", i, Utf8Str(name).raw());
     405        }
     406
     407#if 0
     408        {
     409            RTPrintf("Testing [out] arrays...\n");
    413410            com::SafeGUIDArray uuids;
    414             CHECK_ERROR_BREAK (virtualBox,
    415                                COMGETTER(Uuids) (ComSafeArrayAsOutParam (uuids)));
     411            CHECK_ERROR_BREAK(virtualBox,
     412                              COMGETTER(Uuids)(ComSafeArrayAsOutParam(uuids)));
    416413
    417414            for (size_t i = 0; i < uuids.size(); ++ i)
    418                 RTPrintf ("uuids[%u]=%RTuuid\n", i, &uuids [i]);
    419         }
    420 
    421         {
    422             RTPrintf ("Testing [in] arrays...\n");
    423             com::SafeGUIDArray uuids (5);
     415                RTPrintf("uuids[%u]=%RTuuid\n", i, &uuids[i]);
     416        }
     417
     418        {
     419            RTPrintf("Testing [in] arrays...\n");
     420            com::SafeGUIDArray uuids(5);
    424421            for (size_t i = 0; i < uuids.size(); ++ i)
    425422            {
    426423                Guid id;
    427424                id.create();
    428                 uuids [i] = id;
    429                 RTPrintf ("uuids[%u]=%RTuuid\n", i, &uuids [i]);
     425                uuids[i] = id;
     426                RTPrintf("uuids[%u]=%RTuuid\n", i, &uuids[i]);
    430427            }
    431428
    432             CHECK_ERROR_BREAK (virtualBox,
    433                                SetUuids (ComSafeArrayAsInParam (uuids)));
     429            CHECK_ERROR_BREAK(virtualBox,
     430                              SetUuids(ComSafeArrayAsInParam(uuids)));
    434431        }
    435432#endif
    … …  
    501498        RTPrintf("Call failed\n");
    502499    }
    503     RTPrintf ("\n");
     500    RTPrintf("\n");
    504501#endif
    505502
    … …  
    514511        ComPtr<IHardDisk> hardDisk;
    515512        rc = virtualBox->GetHardDisk(uuid, hardDisk.asOutParam());
    516         RTPrintf ("virtualBox->GetHardDisk(null-uuid)=%08X\n", rc);
     513        RTPrintf("virtualBox->GetHardDisk(null-uuid)=%08X\n", rc);
    517514
    518515//        {
    519 //            com::ErrorInfo info (virtualBox);
    520 //            PRINT_ERROR_INFO (info);
     516//            com::ErrorInfo info(virtualBox);
     517//            PRINT_ERROR_INFO(info);
    521518//        }
    522519
    523520        // call a method that will definitely succeed
    524521        Bstr version;
    525         rc = virtualBox->COMGETTER(Version) (version.asOutParam());
    526         RTPrintf ("virtualBox->COMGETTER(Version)=%08X\n", rc);
    527 
    528         {
    529             com::ErrorInfo info (virtualBox);
    530             PRINT_ERROR_INFO (info);
     522        rc = virtualBox->COMGETTER(Version)(version.asOutParam());
     523        RTPrintf("virtualBox->COMGETTER(Version)=%08X\n", rc);
     524
     525        {
     526            com::ErrorInfo info(virtualBox);
     527            PRINT_ERROR_INFO(info);
    531528        }
    532529
    … …  
    536533        ComPtr<IMachine> machine;
    537534        rc = session->COMGETTER(Machine)(machine.asOutParam());
    538         RTPrintf ("session->COMGETTER(Machine)=%08X\n", rc);
     535        RTPrintf("session->COMGETTER(Machine)=%08X\n", rc);
    539536
    540537//        {
    541 //            com::ErrorInfo info (virtualBox);
    542 //            PRINT_ERROR_INFO (info);
     538//            com::ErrorInfo info(virtualBox);
     539//            PRINT_ERROR_INFO(info);
    543540//        }
    544541
    545542        // call a method that will definitely succeed
    546543        SessionState_T state;
    547         rc = session->COMGETTER(State) (&state);
    548         RTPrintf ("session->COMGETTER(State)=%08X\n", rc);
    549 
    550         {
    551             com::ErrorInfo info (virtualBox);
    552             PRINT_ERROR_INFO (info);
     544        rc = session->COMGETTER(State)(&state);
     545        RTPrintf("session->COMGETTER(State)=%08X\n", rc);
     546
     547        {
     548            com::ErrorInfo info(virtualBox);
     549            PRINT_ERROR_INFO(info);
    553550        }
    554551    }
    … …  
    562559        ComPtr<IHardDisk> hd;
    563560        Bstr src = L"E:\\develop\\innotek\\images\\NewHardDisk.vdi";
    564         RTPrintf ("Opening the existing hard disk '%ls'...\n", src.raw());
    565         CHECK_ERROR_BREAK (virtualBox, OpenHardDisk (src, AccessMode_ReadWrite, hd.asOutParam()));
    566         RTPrintf ("Enter to continue...\n");
     561        RTPrintf("Opening the existing hard disk '%ls'...\n", src.raw());
     562        CHECK_ERROR_BREAK(virtualBox, OpenHardDisk(src, AccessMode_ReadWrite, hd.asOutParam()));
     563        RTPrintf("Enter to continue...\n");
    567564        getchar();
    568         RTPrintf ("Registering the existing hard disk '%ls'...\n", src.raw());
    569         CHECK_ERROR_BREAK (virtualBox, RegisterHardDisk (hd));
    570         RTPrintf ("Enter to continue...\n");
     565        RTPrintf("Registering the existing hard disk '%ls'...\n", src.raw());
     566        CHECK_ERROR_BREAK(virtualBox, RegisterHardDisk(hd));
     567        RTPrintf("Enter to continue...\n");
    571568        getchar();
    572569    }
    573570    while (FALSE);
    574     RTPrintf ("\n");
     571    RTPrintf("\n");
    575572#endif
    576573
    … …  
    582579        ComPtr<IVirtualDiskImage> vdi;
    583580        Bstr src = L"CreatorTest.vdi";
    584         RTPrintf ("Unregistering the hard disk '%ls'...\n", src.raw());
    585         CHECK_ERROR_BREAK (virtualBox, FindVirtualDiskImage (src, vdi.asOutParam()));
     581        RTPrintf("Unregistering the hard disk '%ls'...\n", src.raw());
     582        CHECK_ERROR_BREAK(virtualBox, FindVirtualDiskImage(src, vdi.asOutParam()));
    586583        ComPtr<IHardDisk> hd = vdi;
    587584        Guid id;
    588         CHECK_ERROR_BREAK (hd, COMGETTER(Id) (id.asOutParam()));
    589         CHECK_ERROR_BREAK (virtualBox, UnregisterHardDisk (id, hd.asOutParam()));
     585        CHECK_ERROR_BREAK(hd, COMGETTER(Id)(id.asOutParam()));
     586        CHECK_ERROR_BREAK(virtualBox, UnregisterHardDisk(id, hd.asOutParam()));
    590587    }
    591588    while (FALSE);
    592     RTPrintf ("\n");
     589    RTPrintf("\n");
    593590#endif
    594591
    … …  
    604601#endif
    605602        Bstr dst = L"./clone.vdi";
    606         RTPrintf ("Cloning '%ls' to '%ls'...\n", src.raw(), dst.raw());
     603        RTPrintf("Cloning '%ls' to '%ls'...\n", src.raw(), dst.raw());
    607604        ComPtr<IVirtualDiskImage> vdi;
    608         CHECK_ERROR_BREAK (virtualBox, FindVirtualDiskImage (src, vdi.asOutParam()));
     605        CHECK_ERROR_BREAK(virtualBox, FindVirtualDiskImage(src, vdi.asOutParam()));
    609606        ComPtr<IHardDisk> hd = vdi;
    610607        ComPtr<IProgress> progress;
    611         CHECK_ERROR_BREAK (hd, CloneToImage (dst, vdi.asOutParam(), progress.asOutParam()));
    612         RTPrintf ("Waiting for completion...\n");
    613         CHECK_ERROR_BREAK (progress, WaitForCompletion (-1));
    614         ProgressErrorInfo ei (progress);
    615         if (FAILED (ei.getResultCode()))
    616         {
    617             PRINT_ERROR_INFO (ei);
     608        CHECK_ERROR_BREAK(hd, CloneToImage(dst, vdi.asOutParam(), progress.asOutParam()));
     609        RTPrintf("Waiting for completion...\n");
     610        CHECK_ERROR_BREAK(progress, WaitForCompletion(-1));
     611        ProgressErrorInfo ei(progress);
     612        if (FAILED(ei.getResultCode()))
     613        {
     614            PRINT_ERROR_INFO(ei);
    618615        }
    619616        else
    620617        {
    621             vdi->COMGETTER(FilePath) (dst.asOutParam());
    622             RTPrintf ("Actual clone path is '%ls'\n", dst.raw());
     618            vdi->COMGETTER(FilePath)(dst.asOutParam());
     619            RTPrintf("Actual clone path is '%ls'\n", dst.raw());
    623620        }
    624621    }
    625622    while (FALSE);
    626     RTPrintf ("\n");
     623    RTPrintf("\n");
    627624#endif
    628625
    … …  
    646643        };
    647644
    648         RTPrintf ("\n");
    649 
    650         for (size_t i = 0; i < RT_ELEMENTS (Names); ++ i)
    651         {
    652             Bstr src = Names [i];
    653             RTPrintf ("Searching for hard disk '%ls'...\n", src.raw());
    654             rc = virtualBox->FindHardDisk (src, hd.asOutParam());
     645        RTPrintf("\n");
     646
     647        for (size_t i = 0; i < RT_ELEMENTS(Names); ++ i)
     648        {
     649            Bstr src = Names[i];
     650            RTPrintf("Searching for hard disk '%ls'...\n", src.raw());
     651            rc = virtualBox->FindHardDisk(src, hd.asOutParam());
    655652            if (SUCCEEDED(rc))
    656653            {
    657654                Guid id;
    658655                Bstr location;
    659                 CHECK_ERROR_BREAK (hd, COMGETTER(Id) (id.asOutParam()));
    660                 CHECK_ERROR_BREAK (hd, COMGETTER(Location) (location.asOutParam()));
    661                 RTPrintf ("Found, UUID={%RTuuid}, location='%ls'.\n",
     656                CHECK_ERROR_BREAK(hd, COMGETTER(Id)(id.asOutParam()));
     657                CHECK_ERROR_BREAK(hd, COMGETTER(Location)(location.asOutParam()));
     658                RTPrintf("Found, UUID={%RTuuid}, location='%ls'.\n",
    662659                        id.raw(), location.raw());
    663660
    … …  
    665662                com::SafeArray<BSTR> values;
    666663
    667                 CHECK_ERROR_BREAK (hd, GetProperties (NULL,
    668                                                       ComSafeArrayAsOutParam (names),
    669                                                       ComSafeArrayAsOutParam (values)));
    670 
    671                 RTPrintf ("Properties:\n");
     664                CHECK_ERROR_BREAK(hd, GetProperties(NULL,
     665                                                    ComSafeArrayAsOutParam(names),
     666                                                    ComSafeArrayAsOutParam(values)));
     667
     668                RTPrintf("Properties:\n");
    672669                for (size_t i = 0; i < names.size(); ++ i)
    673                     RTPrintf (" %ls = %ls\n", names [i], values [i]);
     670                    RTPrintf(" %ls = %ls\n", names[i], values[i]);
    674671
    675672                if (names.size() == 0)
    676                     RTPrintf (" <none>\n");
    677 
    678 #if 0
    679                 Bstr name ("TargetAddress");
    680                 Bstr value = Utf8StrFmt ("lalala (%llu)", RTTimeMilliTS());
    681 
    682                 RTPrintf ("Settings property %ls to %ls...\n", name.raw(), value.raw());
    683                 CHECK_ERROR (hd, SetProperty (name, value));
     673                    RTPrintf(" <none>\n");
     674
     675#if 0
     676                Bstr name("TargetAddress");
     677                Bstr value = Utf8StrFmt("lalala (%llu)", RTTimeMilliTS());
     678
     679                RTPrintf("Settings property %ls to %ls...\n", name.raw(), value.raw());
     680                CHECK_ERROR(hd, SetProperty(name, value));
    684681#endif
    685682            }
    686683            else
    687684            {
    688                 com::ErrorInfo info (virtualBox);
    689                 PRINT_ERROR_INFO (info);
     685                com::ErrorInfo info(virtualBox);
     686                PRINT_ERROR_INFO(info);
    690687            }
    691             RTPrintf ("\n");
     688            RTPrintf("\n");
    692689        }
    693690    }
    694691    while (FALSE);
    695     RTPrintf ("\n");
     692    RTPrintf("\n");
    696693#endif
    697694
    … …  
    702699    {
    703700        ComPtr<IMachine> machine;
    704         Bstr name = argc > 1 ? argv [1] : "dos";
    705         RTPrintf ("Getting a machine object named '%ls'...\n", name.raw());
    706         CHECK_ERROR_BREAK (virtualBox, FindMachine (name, machine.asOutParam()));
    707         RTPrintf ("Accessing the machine in read-only mode:\n");
    708         readAndChangeMachineSettings (machine);
     701        Bstr name = argc > 1 ? argv[1] : "dos";
     702        RTPrintf("Getting a machine object named '%ls'...\n", name.raw());
     703        CHECK_ERROR_BREAK(virtualBox, FindMachine(name, machine.asOutParam()));
     704        RTPrintf("Accessing the machine in read-only mode:\n");
     705        readAndChangeMachineSettings(machine);
    709706#if 0
    710707        if (argc != 2)
    711708        {
    712             RTPrintf ("Error: a string has to be supplied!\n");
     709            RTPrintf("Error: a string has to be supplied!\n");
    713710        }
    714711        else
    … …  
    720717    }
    721718    while (0);
    722     RTPrintf ("\n");
     719    RTPrintf("\n");
    723720#endif
    724721
    … …  
    729726    {
    730727        ComPtr<IMachine> machine;
    731 #if defined (RT_OS_LINUX)
     728#if defined(RT_OS_LINUX)
    732729        Bstr baseDir = L"/tmp/vbox";
    733730#else
    … …  
    736733        Bstr name = L"machina";
    737734
    738         RTPrintf ("Creating a new machine object (base dir '%ls', name '%ls')...\n",
     735        RTPrintf("Creating a new machine object(base dir '%ls', name '%ls')...\n",
    739736                baseDir.raw(), name.raw());
    740         CHECK_ERROR_BREAK (virtualBox, CreateMachine (name, L"", baseDir, L"",
    741                                                       false,
    742                                                       machine.asOutParam()));
    743 
    744         RTPrintf ("Getting name...\n");
    745         CHECK_ERROR_BREAK (machine, COMGETTER(Name) (name.asOutParam()));
    746         RTPrintf ("Name: {%ls}\n", name.raw());
     737        CHECK_ERROR_BREAK(virtualBox, CreateMachine(name, L"", baseDir, L"",
     738                                                    false,
     739                                                    machine.asOutParam()));
     740
     741        RTPrintf("Getting name...\n");
     742        CHECK_ERROR_BREAK(machine, COMGETTER(Name)(name.asOutParam()));
     743        RTPrintf("Name: {%ls}\n", name.raw());
    747744
    748745        BOOL modified = FALSE;
    749         RTPrintf ("Are any settings modified?...\n");
    750         CHECK_ERROR_BREAK (machine, COMGETTER(SettingsModified) (&modified));
    751         RTPrintf ("%s\n", modified ? "yes" : "no");
    752 
    753         ASSERT_BREAK (modified == TRUE);
     746        RTPrintf("Are any settings modified?...\n");
     747        CHECK_ERROR_BREAK(machine, COMGETTER(SettingsModified)(&modified));
     748        RTPrintf("%s\n", modified ? "yes" : "no");
     749
     750        ASSERT_BREAK(modified == TRUE);
    754751
    755752        name = L"Kakaya prekrasnaya virtual'naya mashina!";
    756         RTPrintf ("Setting new name ({%ls})...\n", name.raw());
    757         CHECK_ERROR_BREAK (machine, COMSETTER(Name) (name));
    758 
    759         RTPrintf ("Setting memory size to 111...\n");
    760         CHECK_ERROR_BREAK (machine, COMSETTER(MemorySize) (111));
     753        RTPrintf("Setting new name ({%ls})...\n", name.raw());
     754        CHECK_ERROR_BREAK(machine, COMSETTER(Name)(name));
     755
     756        RTPrintf("Setting memory size to 111...\n");
     757        CHECK_ERROR_BREAK(machine, COMSETTER(MemorySize)(111));
    761758
    762759        Bstr desc = L"This is an exemplary description.";
    763         RTPrintf ("Setting description to \"%ls\"...\n", desc.raw());
    764         CHECK_ERROR_BREAK (machine, COMSETTER(Description) (desc));
     760        RTPrintf("Setting description to \"%ls\"...\n", desc.raw());
     761        CHECK_ERROR_BREAK(machine, COMSETTER(Description)(desc));
    765762
    766763        ComPtr<IGuestOSType> guestOSType;
    767764        Bstr type = L"os2warp45";
    768         CHECK_ERROR_BREAK (virtualBox, GetGuestOSType (type, guestOSType.asOutParam()));
    769 
    770         RTPrintf ("Saving new machine settings...\n");
    771         CHECK_ERROR_BREAK (machine, SaveSettings());
    772 
    773         RTPrintf ("Accessing the newly created machine:\n");
    774         readAndChangeMachineSettings (machine);
     765        CHECK_ERROR_BREAK(virtualBox, GetGuestOSType(type, guestOSType.asOutParam()));
     766
     767        RTPrintf("Saving new machine settings...\n");
     768        CHECK_ERROR_BREAK(machine, SaveSettings());
     769
     770        RTPrintf("Accessing the newly created machine:\n");
     771        readAndChangeMachineSettings(machine);
    775772    }
    776773    while (FALSE);
    777     RTPrintf ("\n");
     774    RTPrintf("\n");
    778775#endif
    779776
    … …  
    784781    {
    785782        ComPtr<IHost> host;
    786         CHECK_RC_BREAK (virtualBox->COMGETTER(Host) (host.asOutParam()));
     783        CHECK_RC_BREAK(virtualBox->COMGETTER(Host)(host.asOutParam()));
    787784
    788785        {
    789786            ComPtr<IHostDVDDriveCollection> coll;
    790             CHECK_RC_BREAK (host->COMGETTER(DVDDrives) (coll.asOutParam()));
     787            CHECK_RC_BREAK(host->COMGETTER(DVDDrives)(coll.asOutParam()));
    791788            ComPtr<IHostDVDDriveEnumerator> enumerator;
    792             CHECK_RC_BREAK (coll->Enumerate (enumerator.asOutParam()));
     789            CHECK_RC_BREAK(coll->Enumerate(enumerator.asOutParam()));
    793790            BOOL hasmore;
    794             while (SUCCEEDED(enumerator->HasMore (&hasmore)) && hasmore)
     791            while (SUCCEEDED(enumerator->HasMore(&hasmore)) && hasmore)
    795792            {
    796793                ComPtr<IHostDVDDrive> drive;
    797                 CHECK_RC_BREAK (enumerator->GetNext (drive.asOutParam()));
     794                CHECK_RC_BREAK(enumerator->GetNext(drive.asOutParam()));
    798795                Bstr name;
    799                 CHECK_RC_BREAK (drive->COMGETTER(Name) (name.asOutParam()));
    800                 RTPrintf ("Host DVD drive: name={%ls}\n", name.raw());
     796                CHECK_RC_BREAK(drive->COMGETTER(Name)(name.asOutParam()));
     797                RTPrintf("Host DVD drive: name={%ls}\n", name.raw());
    801798            }
    802             CHECK_RC_BREAK (rc);
     799            CHECK_RC_BREAK(rc);
    803800
    804801            ComPtr<IHostDVDDrive> drive;
    805             CHECK_ERROR (enumerator, GetNext (drive.asOutParam()));
    806             CHECK_ERROR (coll, GetItemAt (1000, drive.asOutParam()));
    807             CHECK_ERROR (coll, FindByName (Bstr ("R:"), drive.asOutParam()));
     802            CHECK_ERROR(enumerator, GetNext(drive.asOutParam()));
     803            CHECK_ERROR(coll, GetItemAt(1000, drive.asOutParam()));
     804            CHECK_ERROR(coll, FindByName(Bstr("R:"), drive.asOutParam()));
    808805            if (SUCCEEDED(rc))
    809806            {
    810807                Bstr name;
    811                 CHECK_RC_BREAK (drive->COMGETTER(Name) (name.asOutParam()));
    812                 RTPrintf ("Found by name: name={%ls}\n", name.raw());
     808                CHECK_RC_BREAK(drive->COMGETTER(Name)(name.asOutParam()));
     809                RTPrintf("Found by name: name={%ls}\n", name.raw());
    813810            }
    814811        }
    815812    }
    816813    while (FALSE);
    817     RTPrintf ("\n");
     814    RTPrintf("\n");
    818815#endif
    819816
    … …  
    824821        RTPrintf("Supported hard disk backends: --------------------------\n");
    825822        ComPtr<ISystemProperties> systemProperties;
    826         CHECK_ERROR_BREAK (virtualBox,
    827                            COMGETTER(SystemProperties) (systemProperties.asOutParam()));
     823        CHECK_ERROR_BREAK(virtualBox,
     824                          COMGETTER(SystemProperties)(systemProperties.asOutParam()));
    828825        com::SafeIfaceArray<IHardDiskFormat> hardDiskFormats;
    829         CHECK_ERROR_BREAK (systemProperties,
    830                            COMGETTER(HardDiskFormats) (ComSafeArrayAsOutParam (hardDiskFormats)));
     826        CHECK_ERROR_BREAK(systemProperties,
     827                          COMGETTER(HardDiskFormats)(ComSafeArrayAsOutParam(hardDiskFormats)));
    831828
    832829        for (size_t i = 0; i < hardDiskFormats.size(); ++ i)
    … …  
    834831            /* General information */
    835832            Bstr id;
    836             CHECK_ERROR_BREAK (hardDiskFormats [i],
    837                                COMGETTER(Id) (id.asOutParam()));
     833            CHECK_ERROR_BREAK(hardDiskFormats[i],
     834                              COMGETTER(Id)(id.asOutParam()));
    838835
    839836            Bstr description;
    840             CHECK_ERROR_BREAK (hardDiskFormats [i],
    841                                COMGETTER(Id) (description.asOutParam()));
     837            CHECK_ERROR_BREAK(hardDiskFormats[i],
     838                              COMGETTER(Id)(description.asOutParam()));
    842839
    843840            ULONG caps;
    844             CHECK_ERROR_BREAK (hardDiskFormats [i],
    845                                COMGETTER(Capabilities) (&caps));
     841            CHECK_ERROR_BREAK(hardDiskFormats[i],
     842                              COMGETTER(Capabilities)(&caps));
    846843
    847844            RTPrintf("Backend %u: id='%ls' description='%ls' capabilities=%#06x extensions='",
    … …  
    850847            /* File extensions */
    851848            com::SafeArray<BSTR> fileExtensions;
    852             CHECK_ERROR_BREAK (hardDiskFormats [i],
    853                                COMGETTER(FileExtensions) (ComSafeArrayAsOutParam (fileExtensions)));
     849            CHECK_ERROR_BREAK(hardDiskFormats[i],
     850                              COMGETTER(FileExtensions)(ComSafeArrayAsOutParam(fileExtensions)));
    854851            for (size_t a = 0; a < fileExtensions.size(); ++ a)
    855852            {
    856                 RTPrintf ("%ls", Bstr (fileExtensions [a]).raw());
     853                RTPrintf("%ls", Bstr(fileExtensions[a]).raw());
    857854                if (a != fileExtensions.size()-1)
    858                     RTPrintf (",");
     855                    RTPrintf(",");
    859856            }
    860             RTPrintf ("'");
     857            RTPrintf("'");
    861858
    862859            /* Configuration keys */
    … …  
    866863            com::SafeArray<ULONG> propertyFlags;
    867864            com::SafeArray<BSTR> propertyDefaults;
    868             CHECK_ERROR_BREAK (hardDiskFormats [i],
    869                                DescribeProperties (ComSafeArrayAsOutParam (propertyNames),
    870                                                    ComSafeArrayAsOutParam (propertyDescriptions),
    871                                                    ComSafeArrayAsOutParam (propertyTypes),
    872                                                    ComSafeArrayAsOutParam (propertyFlags),
    873                                                    ComSafeArrayAsOutParam (propertyDefaults)));
    874 
    875             RTPrintf (" config=(");
     865            CHECK_ERROR_BREAK(hardDiskFormats[i],
     866                              DescribeProperties(ComSafeArrayAsOutParam(propertyNames),
     867                                                 ComSafeArrayAsOutParam(propertyDescriptions),
     868                                                 ComSafeArrayAsOutParam(propertyTypes),
     869                                                 ComSafeArrayAsOutParam(propertyFlags),
     870                                                 ComSafeArrayAsOutParam(propertyDefaults)));
     871
     872            RTPrintf(" config=(");
    876873            if (propertyNames.size() > 0)
    877874            {
    878875                for (size_t a = 0; a < propertyNames.size(); ++ a)
    879876                {
    880                     RTPrintf ("key='%ls' desc='%ls' type=", Bstr (propertyNames [a]).raw(), Bstr (propertyDescriptions [a]).raw());
    881                     switch (propertyTypes [a])
     877                    RTPrintf("key='%ls' desc='%ls' type=", Bstr(propertyNames[a]).raw(), Bstr(propertyDescriptions[a]).raw());
     878                    switch (propertyTypes[a])
    882879                    {
    883                         case DataType_Int32Type: RTPrintf ("int"); break;
    884                         case DataType_Int8Type: RTPrintf ("byte"); break;
    885                         case DataType_StringType: RTPrintf ("string"); break;
     880                        case DataType_Int32Type: RTPrintf("int"); break;
     881                        case DataType_Int8Type: RTPrintf("byte"); break;
     882                        case DataType_StringType: RTPrintf("string"); break;
    886883                    }
    887                     RTPrintf (" flags=%#04x", propertyFlags [a]);
    888                     RTPrintf (" default='%ls'", Bstr (propertyDefaults [a]).raw());
     884                    RTPrintf(" flags=%#04x", propertyFlags[a]);
     885                    RTPrintf(" default='%ls'", Bstr(propertyDefaults[a]).raw());
    889886                    if (a != propertyNames.size()-1)
    890                         RTPrintf (",");
     887                        RTPrintf(",");
    891888                }
    892889            }
    893             RTPrintf (")\n");
     890            RTPrintf(")\n");
    894891        }
    895892        RTPrintf("-------------------------------------------------------\n");
    … …  
    904901        {
    905902            com::SafeIfaceArray<IHardDisk> disks;
    906             CHECK_ERROR_BREAK (virtualBox,
    907                                COMGETTER(HardDisks)(ComSafeArrayAsOutParam (disks)));
    908 
    909             RTPrintf ("%u base hard disks registered (disks.isNull()=%d).\n",
     903            CHECK_ERROR_BREAK(virtualBox,
     904                              COMGETTER(HardDisks)(ComSafeArrayAsOutParam(disks)));
     905
     906            RTPrintf("%u base hard disks registered (disks.isNull()=%d).\n",
    910907                    disks.size(), disks.isNull());
    911908
    … …  
    913910            {
    914911                Bstr loc;
    915                 CHECK_ERROR_BREAK (disks [i], COMGETTER(Location) (loc.asOutParam()));
     912                CHECK_ERROR_BREAK(disks[i], COMGETTER(Location)(loc.asOutParam()));
    916913                Guid id;
    917                 CHECK_ERROR_BREAK (disks [i], COMGETTER(Id) (id.asOutParam()));
     914                CHECK_ERROR_BREAK(disks[i], COMGETTER(Id)(id.asOutParam()));
    918915                MediaState_T state;
    919                 CHECK_ERROR_BREAK (disks [i], COMGETTER(State) (&state));
     916                CHECK_ERROR_BREAK(disks[i], COMGETTER(State)(&state));
    920917                Bstr format;
    921                 CHECK_ERROR_BREAK (disks [i], COMGETTER(Format) (format.asOutParam()));
    922 
    923                 RTPrintf (" disks[%u]: '%ls'\n"
     918                CHECK_ERROR_BREAK(disks[i], COMGETTER(Format)(format.asOutParam()));
     919
     920                RTPrintf(" disks[%u]: '%ls'\n"
    924921                        "  UUID:         {%RTuuid}\n"
    925922                        "  State:        %s\n"
    … …  
    937934                {
    938935                    Bstr error;
    939                     CHECK_ERROR_BREAK (disks [i],
    940                                        COMGETTER(LastAccessError)(error.asOutParam()));
    941                     RTPrintf ("  Access Error: %ls\n", error.raw());
     936                    CHECK_ERROR_BREAK(disks[i],
     937                                      COMGETTER(LastAccessError)(error.asOutParam()));
     938                    RTPrintf("  Access Error: %ls\n", error.raw());
    942939                }
    943940
    944941                /* get usage */
    945942
    946                 RTPrintf ("  Used by VMs:\n");
     943                RTPrintf("  Used by VMs:\n");
    947944
    948945                com::SafeGUIDArray ids;
    949                 CHECK_ERROR_BREAK (disks [i],
    950                                    COMGETTER(MachineIds) (ComSafeArrayAsOutParam (ids)));
     946                CHECK_ERROR_BREAK(disks[i],
     947                                  COMGETTER(MachineIds)(ComSafeArrayAsOutParam(ids)));
    951948                if (ids.size() == 0)
    952949                {
    953                     RTPrintf ("   <not used>\n");
     950                    RTPrintf("   <not used>\n");
    954951                }
    955952                else
    … …  
    957954                    for (size_t j = 0; j < ids.size(); ++ j)
    958955                    {
    959                         RTPrintf ("   {%RTuuid}\n", &ids [j]);
     956                        RTPrintf("   {%RTuuid}\n", &ids[j]);
    960957                    }
    961958                }
    … …  
    964961        {
    965962            com::SafeIfaceArray<IDVDImage> images;
    966             CHECK_ERROR_BREAK (virtualBox,
    967                                COMGETTER(DVDImages) (ComSafeArrayAsOutParam (images)));
    968 
    969             RTPrintf ("%u DVD images registered (images.isNull()=%d).\n",
     963            CHECK_ERROR_BREAK(virtualBox,
     964                              COMGETTER(DVDImages)(ComSafeArrayAsOutParam(images)));
     965
     966            RTPrintf("%u DVD images registered (images.isNull()=%d).\n",
    970967                    images.size(), images.isNull());
    971968
    … …  
    973970            {
    974971                Bstr loc;
    975                 CHECK_ERROR_BREAK (images [i], COMGETTER(Location) (loc.asOutParam()));
     972                CHECK_ERROR_BREAK(images[i], COMGETTER(Location)(loc.asOutParam()));
    976973                Guid id;
    977                 CHECK_ERROR_BREAK (images [i], COMGETTER(Id) (id.asOutParam()));
     974                CHECK_ERROR_BREAK(images[i], COMGETTER(Id)(id.asOutParam()));
    978975                MediaState_T state;
    979                 CHECK_ERROR_BREAK (images [i], COMGETTER(State) (&state));
    980 
    981                 RTPrintf (" images[%u]: '%ls'\n"
     976                CHECK_ERROR_BREAK(images[i], COMGETTER(State)(&state));
     977
     978                RTPrintf(" images[%u]: '%ls'\n"
    982979                        "  UUID:         {%RTuuid}\n"
    983980                        "  State:        %s\n",
    … …  
    993990                {
    994991                    Bstr error;
    995                     CHECK_ERROR_BREAK (images [i],
    996                                        COMGETTER(LastAccessError)(error.asOutParam()));
    997                     RTPrintf ("  Access Error: %ls\n", error.raw());
     992                    CHECK_ERROR_BREAK(images[i],
     993                                      COMGETTER(LastAccessError)(error.asOutParam()));
     994                    RTPrintf("  Access Error: %ls\n", error.raw());
    998995                }
    999996
    1000997                /* get usage */
    1001998
    1002                 RTPrintf ("  Used by VMs:\n");
     999                RTPrintf("  Used by VMs:\n");
    10031000
    10041001                com::SafeGUIDArray ids;
    1005                 CHECK_ERROR_BREAK (images [i],
    1006                                    COMGETTER(MachineIds) (ComSafeArrayAsOutParam (ids)));
     1002                CHECK_ERROR_BREAK(images[i],
     1003                                  COMGETTER(MachineIds)(ComSafeArrayAsOutParam(ids)));
    10071004                if (ids.size() == 0)
    10081005                {
    1009                     RTPrintf ("   <not used>\n");
     1006                    RTPrintf("   <not used>\n");
    10101007                }
    10111008                else
    … …  
    10131010                    for (size_t j = 0; j < ids.size(); ++ j)
    10141011                    {
    1015                         RTPrintf ("   {%RTuuid}\n", &ids [j]);
     1012                        RTPrintf("   {%RTuuid}\n", &ids[j]);
    10161013                    }
    10171014                }
    … …  
    10201017    }
    10211018    while (FALSE);
    1022     RTPrintf ("\n");
     1019    RTPrintf("\n");
    10231020#endif
    10241021
    … …  
    10291026    {
    10301027        ComPtr<IMachine> machine;
    1031         Bstr name = argc > 1 ? argv [1] : "dos";
    1032         RTPrintf ("Getting a machine object named '%ls'...\n", name.raw());
    1033         CHECK_ERROR_BREAK (virtualBox, FindMachine (name, machine.asOutParam()));
     1028        Bstr name = argc > 1 ? argv[1] : "dos";
     1029        RTPrintf("Getting a machine object named '%ls'...\n", name.raw());
     1030        CHECK_ERROR_BREAK(virtualBox, FindMachine(name, machine.asOutParam()));
    10341031        Guid guid;
    1035         CHECK_RC_BREAK (machine->COMGETTER(Id) (guid.asOutParam()));
    1036         RTPrintf ("Opening a session for this machine...\n");
    1037         CHECK_RC_BREAK (virtualBox->OpenSession (session, guid));
     1032        CHECK_RC_BREAK(machine->COMGETTER(Id)(guid.asOutParam()));
     1033        RTPrintf("Opening a session for this machine...\n");
     1034        CHECK_RC_BREAK(virtualBox->OpenSession(session, guid));
    10381035#if 1
    10391036        ComPtr<IMachine> sessionMachine;
    1040         RTPrintf ("Getting sessioned machine object...\n");
    1041         CHECK_RC_BREAK (session->COMGETTER(Machine) (sessionMachine.asOutParam()));
    1042         RTPrintf ("Accessing the machine within the session:\n");
    1043         readAndChangeMachineSettings (sessionMachine, machine);
    1044 #if 0
    1045         RTPrintf ("\n");
    1046         RTPrintf ("Enabling the VRDP server (must succeed even if the VM is saved):\n");
     1037        RTPrintf("Getting sessioned machine object...\n");
     1038        CHECK_RC_BREAK(session->COMGETTER(Machine)(sessionMachine.asOutParam()));
     1039        RTPrintf("Accessing the machine within the session:\n");
     1040        readAndChangeMachineSettings(sessionMachine, machine);
     1041#if 0
     1042        RTPrintf("\n");
     1043        RTPrintf("Enabling the VRDP server (must succeed even if the VM is saved):\n");
    10471044        ComPtr<IVRDPServer> vrdp;
    1048         CHECK_ERROR_BREAK (sessionMachine, COMGETTER(VRDPServer) (vrdp.asOutParam()));
    1049         if (FAILED (vrdp->COMSETTER(Enabled) (TRUE)))
    1050         {
    1051             PRINT_ERROR_INFO (com::ErrorInfo (vrdp));
     1045        CHECK_ERROR_BREAK(sessionMachine, COMGETTER(VRDPServer)(vrdp.asOutParam()));
     1046        if (FAILED(vrdp->COMSETTER(Enabled)(TRUE)))
     1047        {
     1048            PRINT_ERROR_INFO(com::ErrorInfo(vrdp));
    10521049        }
    10531050        else
    10541051        {
    10551052            BOOL enabled = FALSE;
    1056             CHECK_ERROR_BREAK (vrdp, COMGETTER(Enabled) (&enabled));
    1057             RTPrintf ("VRDP server is %s\n", enabled ? "enabled" : "disabled");
     1053            CHECK_ERROR_BREAK(vrdp, COMGETTER(Enabled)(&enabled));
     1054            RTPrintf("VRDP server is %s\n", enabled ? "enabled" : "disabled");
    10581055        }
    10591056#endif
    … …  
    10611058#if 0
    10621059        ComPtr<IConsole> console;
    1063         RTPrintf ("Getting the console object...\n");
    1064         CHECK_RC_BREAK (session->COMGETTER(Console) (console.asOutParam()));
    1065         RTPrintf ("Discarding the current machine state...\n");
     1060        RTPrintf("Getting the console object...\n");
     1061        CHECK_RC_BREAK(session->COMGETTER(Console)(console.asOutParam()));
     1062        RTPrintf("Discarding the current machine state...\n");
    10661063        ComPtr<IProgress> progress;
    1067         CHECK_ERROR_BREAK (console, DiscardCurrentState (progress.asOutParam()));
    1068         RTPrintf ("Waiting for completion...\n");
    1069         CHECK_ERROR_BREAK (progress, WaitForCompletion (-1));
    1070         ProgressErrorInfo ei (progress);
    1071         if (FAILED (ei.getResultCode()))
    1072         {
    1073             PRINT_ERROR_INFO (ei);
     1064        CHECK_ERROR_BREAK(console, DiscardCurrentState(progress.asOutParam()));
     1065        RTPrintf("Waiting for completion...\n");
     1066        CHECK_ERROR_BREAK(progress, WaitForCompletion(-1));
     1067        ProgressErrorInfo ei(progress);
     1068        if (FAILED(ei.getResultCode()))
     1069        {
     1070            PRINT_ERROR_INFO(ei);
    10741071
    10751072            ComPtr<IUnknown> initiator;
    1076             CHECK_ERROR_BREAK (progress, COMGETTER(Initiator) (initiator.asOutParam()));
    1077 
    1078             RTPrintf ("initiator(unk) = %p\n", (IUnknown *) initiator);
    1079             RTPrintf ("console(unk) = %p\n", (IUnknown *) ComPtr<IUnknown> ((IConsole *) console));
    1080             RTPrintf ("console = %p\n", (IConsole *) console);
     1073            CHECK_ERROR_BREAK(progress, COMGETTER(Initiator)(initiator.asOutParam()));
     1074
     1075            RTPrintf("initiator(unk) = %p\n", (IUnknown *)initiator);
     1076            RTPrintf("console(unk) = %p\n", (IUnknown *)ComPtr<IUnknown>((IConsole *)console));
     1077            RTPrintf("console = %p\n", (IConsole *)console);
    10811078        }
    10821079#endif
    … …  
    10861083    }
    10871084    while (FALSE);
    1088     RTPrintf ("\n");
     1085    RTPrintf("\n");
    10891086#endif
    10901087
    … …  
    10961093        ComPtr<IMachine> machine;
    10971094        Bstr name = L"dos";
    1098         RTPrintf ("Getting a machine object named '%ls'...\n", name.raw());
    1099         CHECK_RC_BREAK (virtualBox->FindMachine (name, machine.asOutParam()));
     1095        RTPrintf("Getting a machine object named '%ls'...\n", name.raw());
     1096        CHECK_RC_BREAK(virtualBox->FindMachine(name, machine.asOutParam()));
    11001097        Guid guid;
    1101         CHECK_RC_BREAK (machine->COMGETTER(Id) (guid.asOutParam()));
    1102         RTPrintf ("Opening a remote session for this machine...\n");
     1098        CHECK_RC_BREAK(machine->COMGETTER(Id)(guid.asOutParam()));
     1099        RTPrintf("Opening a remote session for this machine...\n");
    11031100        ComPtr<IProgress> progress;
    1104         CHECK_RC_BREAK (virtualBox->OpenRemoteSession (session, guid, Bstr("gui"),
     1101        CHECK_RC_BREAK(virtualBox->OpenRemoteSession(session, guid, Bstr("gui"),
    11051102                                                       NULL, progress.asOutParam()));
    1106         RTPrintf ("Waiting for the session to open...\n");
    1107         CHECK_RC_BREAK (progress->WaitForCompletion (-1));
     1103        RTPrintf("Waiting for the session to open...\n");
     1104        CHECK_RC_BREAK(progress->WaitForCompletion(-1));
    11081105        ComPtr<IMachine> sessionMachine;
    1109         RTPrintf ("Getting sessioned machine object...\n");
    1110         CHECK_RC_BREAK (session->COMGETTER(Machine) (sessionMachine.asOutParam()));
     1106        RTPrintf("Getting sessioned machine object...\n");
     1107        CHECK_RC_BREAK(session->COMGETTER(Machine)(sessionMachine.asOutParam()));
    11111108        ComPtr<IConsole> console;
    1112         RTPrintf ("Getting console object...\n");
    1113         CHECK_RC_BREAK (session->COMGETTER(Console) (console.asOutParam()));
    1114         RTPrintf ("Press enter to pause the VM execution in the remote session...");
     1109        RTPrintf("Getting console object...\n");
     1110        CHECK_RC_BREAK(session->COMGETTER(Console)(console.asOutParam()));
     1111        RTPrintf("Press enter to pause the VM execution in the remote session...");
    11151112        getchar();
    1116         CHECK_RC (console->Pause());
    1117         RTPrintf ("Press enter to close this session...");
     1113        CHECK_RC(console->Pause());
     1114        RTPrintf("Press enter to close this session...");
    11181115        getchar();
    11191116        session->Close();
    11201117    }
    11211118    while (FALSE);
    1122     RTPrintf ("\n");
     1119    RTPrintf("\n");
    11231120#endif
    11241121
    … …  
    11301127        ComPtr<IMachine> machine;
    11311128        Bstr name = "dos";
    1132         RTPrintf ("Getting a machine object named '%ls'...\n", name.raw());
    1133         CHECK_RC_BREAK (virtualBox->FindMachine (name, machine.asOutParam()));
     1129        RTPrintf("Getting a machine object named '%ls'...\n", name.raw());
     1130        CHECK_RC_BREAK(virtualBox->FindMachine(name, machine.asOutParam()));
    11341131        Guid guid;
    1135         CHECK_RC_BREAK (machine->COMGETTER(Id) (guid.asOutParam()));
    1136         RTPrintf ("Opening an existing remote session for this machine...\n");
    1137         CHECK_RC_BREAK (virtualBox->OpenExistingSession (session, guid));
     1132        CHECK_RC_BREAK(machine->COMGETTER(Id)(guid.asOutParam()));
     1133        RTPrintf("Opening an existing remote session for this machine...\n");
     1134        CHECK_RC_BREAK(virtualBox->OpenExistingSession(session, guid));
    11381135        ComPtr<IMachine> sessionMachine;
    1139         RTPrintf ("Getting sessioned machine object...\n");
    1140         CHECK_RC_BREAK (session->COMGETTER(Machine) (sessionMachine.asOutParam()));
     1136        RTPrintf("Getting sessioned machine object...\n");
     1137        CHECK_RC_BREAK(session->COMGETTER(Machine)(sessionMachine.asOutParam()));
    11411138
    11421139#if 0
    11431140        Bstr extraDataKey = "VBoxSDL/SecureLabel";
    11441141        Bstr extraData = "Das kommt jetzt noch viel krasser vom total konkreten API!";
    1145         CHECK_RC (sessionMachine->SetExtraData (extraDataKey, extraData));
     1142        CHECK_RC(sessionMachine->SetExtraData(extraDataKey, extraData));
    11461143#endif
    11471144#if 0
    11481145        ComPtr<IConsole> console;
    1149         RTPrintf ("Getting console object...\n");
    1150         CHECK_RC_BREAK (session->COMGETTER(Console) (console.asOutParam()));
    1151         RTPrintf ("Press enter to pause the VM execution in the remote session...");
     1146        RTPrintf("Getting console object...\n");
     1147        CHECK_RC_BREAK(session->COMGETTER(Console)(console.asOutParam()));
     1148        RTPrintf("Press enter to pause the VM execution in the remote session...");
    11521149        getchar();
    1153         CHECK_RC (console->Pause());
    1154         RTPrintf ("Press enter to close this session...");
     1150        CHECK_RC(console->Pause());
     1151        RTPrintf("Press enter to close this session...");
    11551152        getchar();
    11561153#endif
    … …  
    11581155    }
    11591156    while (FALSE);
    1160     RTPrintf ("\n");
     1157    RTPrintf("\n");
    11611158#endif
    11621159
    … …  
    11651162        // Get host
    11661163        ComPtr<IHost> host;
    1167         CHECK_ERROR_BREAK (virtualBox, COMGETTER(Host) (host.asOutParam()));
     1164        CHECK_ERROR_BREAK(virtualBox, COMGETTER(Host)(host.asOutParam()));
    11681165
    11691166        ULONG uMemSize, uMemAvail;
    1170         CHECK_ERROR_BREAK (host, COMGETTER(MemorySize) (&uMemSize));
     1167        CHECK_ERROR_BREAK(host, COMGETTER(MemorySize)(&uMemSize));
    11711168        RTPrintf("Total memory (MB): %u\n", uMemSize);
    1172         CHECK_ERROR_BREAK (host, COMGETTER(MemoryAvailable) (&uMemAvail));
     1169        CHECK_ERROR_BREAK(host, COMGETTER(MemoryAvailable)(&uMemAvail));
    11731170        RTPrintf("Free memory (MB): %u\n", uMemAvail);
    11741171    } while (0);
    … …  
    11791176        // Get host
    11801177        ComPtr<IHost> host;
    1181         CHECK_ERROR_BREAK (virtualBox, COMGETTER(Host) (host.asOutParam()));
     1178        CHECK_ERROR_BREAK(virtualBox, COMGETTER(Host)(host.asOutParam()));
    11821179
    11831180        com::SafeIfaceArray<IHostNetworkInterface> hostNetworkInterfaces;
    11841181        CHECK_ERROR_BREAK(host,
    1185                           COMGETTER(NetworkInterfaces) (ComSafeArrayAsOutParam (hostNetworkInterfaces)));
     1182                          COMGETTER(NetworkInterfaces)(ComSafeArrayAsOutParam(hostNetworkInterfaces)));
    11861183        if (hostNetworkInterfaces.size() > 0)
    11871184        {
    … …  
    11951192            networkInterface.setNull();
    11961193            CHECK_ERROR_BREAK(host,
    1197                               FindHostNetworkInterfaceByName (interfaceName, networkInterface.asOutParam()));
     1194                              FindHostNetworkInterfaceByName(interfaceName, networkInterface.asOutParam()));
    11981195            Guid interfaceGuid2;
    11991196            networkInterface->COMGETTER(Id)(interfaceGuid2.asOutParam());
    … …  
    12031200            networkInterface.setNull();
    12041201            CHECK_ERROR_BREAK(host,
    1205                               FindHostNetworkInterfaceById (interfaceGuid, networkInterface.asOutParam()));
     1202                              FindHostNetworkInterfaceById(interfaceGuid, networkInterface.asOutParam()));
    12061203            Bstr interfaceName2;
    12071204            networkInterface->COMGETTER(Name)(interfaceName2.asOutParam());
    … …  
    12161213#endif
    12171214
    1218 #if 0 && defined (VBOX_WITH_RESOURCE_USAGE_API)
     1215#if 0 && defined(VBOX_WITH_RESOURCE_USAGE_API)
    12191216    do {
    12201217        // Get collector
    12211218        ComPtr<IPerformanceCollector> collector;
    1222         CHECK_ERROR_BREAK (virtualBox,
    1223                            COMGETTER(PerformanceCollector) (collector.asOutParam()));
     1219        CHECK_ERROR_BREAK(virtualBox,
     1220                          COMGETTER(PerformanceCollector)(collector.asOutParam()));
    12241221
    12251222
    12261223        // Fill base metrics array
    12271224        Bstr baseMetricNames[] = { L"CPU/Load,RAM/Usage" };
    1228         com::SafeArray<BSTR> baseMetrics (1);
    1229         baseMetricNames[0].cloneTo(&baseMetrics [0]);
     1225        com::SafeArray<BSTR> baseMetrics(1);
     1226        baseMetricNames[0].cloneTo(&baseMetrics[0]);
    12301227
    12311228        // Get host
    12321229        ComPtr<IHost> host;
    1233         CHECK_ERROR_BREAK (virtualBox, COMGETTER(Host) (host.asOutParam()));
     1230        CHECK_ERROR_BREAK(virtualBox, COMGETTER(Host)(host.asOutParam()));
    12341231
    12351232        // Get machine
    12361233        ComPtr<IMachine> machine;
    1237         Bstr name = argc > 1 ? argv [1] : "dsl";
    1238         Bstr sessionType = argc > 2 ? argv [2] : "vrdp";
    1239         RTPrintf ("Getting a machine object named '%ls'...\n", name.raw());
    1240         CHECK_RC_BREAK (virtualBox->FindMachine (name, machine.asOutParam()));
     1234        Bstr name = argc > 1 ? argv[1] : "dsl";
     1235        Bstr sessionType = argc > 2 ? argv[2] : "vrdp";
     1236        RTPrintf("Getting a machine object named '%ls'...\n", name.raw());
     1237        CHECK_RC_BREAK(virtualBox->FindMachine(name, machine.asOutParam()));
    12411238
    12421239        // Open session
    12431240        Guid guid;
    1244         CHECK_RC_BREAK (machine->COMGETTER(Id) (guid.asOutParam()));
    1245         RTPrintf ("Opening a remote session for this machine...\n");
     1241        CHECK_RC_BREAK(machine->COMGETTER(Id)(guid.asOutParam()));
     1242        RTPrintf("Opening a remote session for this machine...\n");
    12461243        ComPtr<IProgress> progress;
    1247         CHECK_RC_BREAK (virtualBox->OpenRemoteSession (session, guid, sessionType,
     1244        CHECK_RC_BREAK(virtualBox->OpenRemoteSession(session, guid, sessionType,
    12481245                                                       NULL, progress.asOutParam()));
    1249         RTPrintf ("Waiting for the session to open...\n");
    1250         CHECK_RC_BREAK (progress->WaitForCompletion (-1));
     1246        RTPrintf("Waiting for the session to open...\n");
     1247        CHECK_RC_BREAK(progress->WaitForCompletion(-1));
    12511248        ComPtr<IMachine> sessionMachine;
    1252         RTPrintf ("Getting sessioned machine object...\n");
    1253         CHECK_RC_BREAK (session->COMGETTER(Machine) (sessionMachine.asOutParam()));
     1249        RTPrintf("Getting sessioned machine object...\n");
     1250        CHECK_RC_BREAK(session->COMGETTER(Machine)(sessionMachine.asOutParam()));
    12541251
    12551252        // Setup base metrics
    … …  
    12591256        host.queryInterfaceTo(&objects[0]);
    12601257        machine.queryInterfaceTo(&objects[1]);
    1261         CHECK_ERROR_BREAK (collector, SetupMetrics(ComSafeArrayAsInParam(baseMetrics),
     1258        CHECK_ERROR_BREAK(collector, SetupMetrics(ComSafeArrayAsInParam(baseMetrics),
    12621259                                                   ComSafeArrayAsInParam(objects), 1u, 10u,
    1263                                                    ComSafeArrayAsOutParam(affectedMetrics)) );
     1260                                                   ComSafeArrayAsOutParam(affectedMetrics)));
    12641261        listAffectedMetrics(virtualBox,
    12651262                            ComSafeArrayAsInParam(affectedMetrics));
    … …  
    12681265        // Get console
    12691266        ComPtr<IConsole> console;
    1270         RTPrintf ("Getting console object...\n");
    1271         CHECK_RC_BREAK (session->COMGETTER(Console) (console.asOutParam()));
     1267        RTPrintf("Getting console object...\n");
     1268        CHECK_RC_BREAK(session->COMGETTER(Console)(console.asOutParam()));
    12721269
    12731270        RTThreadSleep(5000); // Sleep for 5 seconds
    … …  
    12771274
    12781275        // Pause
    1279         //RTPrintf ("Press enter to pause the VM execution in the remote session...");
     1276        //RTPrintf("Press enter to pause the VM execution in the remote session...");
    12801277        //getchar();
    1281         CHECK_RC (console->Pause());
     1278        CHECK_RC(console->Pause());
    12821279
    12831280        RTThreadSleep(5000); // Sleep for 5 seconds
    … …  
    12871284
    12881285        RTPrintf("\nDrop collected metrics: ----------------------------------------\n");
    1289         CHECK_ERROR_BREAK (collector,
     1286        CHECK_ERROR_BREAK(collector,
    12901287            SetupMetrics(ComSafeArrayAsInParam(baseMetrics),
    12911288                         ComSafeArrayAsInParam(objects),
    1292                          1u, 5u, ComSafeArrayAsOutParam(affectedMetrics)) );
     1289                         1u, 5u, ComSafeArrayAsOutParam(affectedMetrics)));
    12931290        listAffectedMetrics(virtualBox,
    12941291                            ComSafeArrayAsInParam(affectedMetrics));
    … …  
    13001297
    13011298        RTPrintf("\nDisable collection of VM metrics: ------------------------------\n");
    1302         CHECK_ERROR_BREAK (collector,
     1299        CHECK_ERROR_BREAK(collector,
    13031300            DisableMetrics(ComSafeArrayAsInParam(baseMetrics),
    13041301                           ComSafeArrayAsInParam(vmObject),
    1305                            ComSafeArrayAsOutParam(affectedMetrics)) );
     1302                           ComSafeArrayAsOutParam(affectedMetrics)));
    13061303        listAffectedMetrics(virtualBox,
    13071304                            ComSafeArrayAsInParam(affectedMetrics));
    … …  
    13111308
    13121309        RTPrintf("\nRe-enable collection of all metrics: ---------------------------\n");
    1313         CHECK_ERROR_BREAK (collector,
     1310        CHECK_ERROR_BREAK(collector,
    13141311            EnableMetrics(ComSafeArrayAsInParam(baseMetrics),
    13151312                          ComSafeArrayAsInParam(objects),
    1316                           ComSafeArrayAsOutParam(affectedMetrics)) );
     1313                          ComSafeArrayAsOutParam(affectedMetrics)));
    13171314        listAffectedMetrics(virtualBox,
    13181315                            ComSafeArrayAsInParam(affectedMetrics));
    … …  
    13221319
    13231320        // Power off
    1324         RTPrintf ("Press enter to power off VM...");
     1321        RTPrintf("Press enter to power off VM...");
    13251322        getchar();
    1326         CHECK_RC (console->PowerDown());
    1327         RTPrintf ("Press enter to close this session...");
     1323        CHECK_RC(console->PowerDown());
     1324        RTPrintf("Press enter to close this session...");
    13281325        getchar();
    13291326        session->Close();
    … …  
    13351332    do
    13361333    {
    1337         Bstr ovf = argc > 1 ? argv [1] : "someOVF.ovf";
    1338         RTPrintf ("Try to open %ls ...\n", ovf.raw());
     1334        Bstr ovf = argc > 1 ? argv[1] : "someOVF.ovf";
     1335        RTPrintf("Try to open %ls ...\n", ovf.raw());
    13391336
    13401337        ComPtr<IAppliance> appliance;
    1341         CHECK_ERROR_BREAK (virtualBox,
    1342                            CreateAppliance (appliance.asOutParam()));
    1343         CHECK_ERROR_BREAK (appliance,
    1344                            Read (ovf));
     1338        CHECK_ERROR_BREAK(virtualBox,
     1339                          CreateAppliance(appliance.asOutParam()));
     1340        CHECK_ERROR_BREAK(appliance, Read(ovf));
    13451341        Bstr path;
    1346         CHECK_ERROR_BREAK (appliance, COMGETTER (Path)(path.asOutParam()));
    1347         RTPrintf ("Successfully opened %ls.\n", path.raw());
    1348         CHECK_ERROR_BREAK (appliance,
    1349                            Interpret());
    1350         RTPrintf ("Successfully interpreted %ls.\n", path.raw());
    1351         RTPrintf ("Appliance:\n");
     1342        CHECK_ERROR_BREAK(appliance, COMGETTER(Path)(path.asOutParam()));
     1343        RTPrintf("Successfully opened %ls.\n", path.raw());
     1344        CHECK_ERROR_BREAK(appliance, Interpret());
     1345        RTPrintf("Successfully interpreted %ls.\n", path.raw());
     1346        RTPrintf("Appliance:\n");
    13521347        // Fetch all disks
    13531348        com::SafeArray<BSTR> retDisks;
    1354         CHECK_ERROR_BREAK (appliance,
    1355                            COMGETTER (Disks)(ComSafeArrayAsOutParam  (retDisks)));
     1349        CHECK_ERROR_BREAK(appliance,
     1350                          COMGETTER(Disks)(ComSafeArrayAsOutParam(retDisks)));
    13561351        if (retDisks.size() > 0)
    13571352        {
    1358             RTPrintf ("Disks:");
     1353            RTPrintf("Disks:");
    13591354            for (unsigned i = 0; i < retDisks.size(); i++)
    1360                 RTPrintf (" %ls", Bstr (retDisks [i]).raw());
    1361             RTPrintf ("\n");
     1355                RTPrintf(" %ls", Bstr(retDisks[i]).raw());
     1356            RTPrintf("\n");
    13621357        }
    13631358        /* Fetch all virtual system descriptions */
    13641359        com::SafeIfaceArray<IVirtualSystemDescription> retVSD;
    1365         CHECK_ERROR_BREAK (appliance,
    1366                            COMGETTER (VirtualSystemDescriptions) (ComSafeArrayAsOutParam (retVSD)));
     1360        CHECK_ERROR_BREAK(appliance,
     1361                          COMGETTER(VirtualSystemDescriptions)(ComSafeArrayAsOutParam(retVSD)));
    13671362        if (retVSD.size() > 0)
    13681363        {
    … …  
    13741369                com::SafeArray<BSTR> retAutoValues;
    13751370                com::SafeArray<BSTR> retConfiguration;
    1376                 CHECK_ERROR_BREAK (retVSD [i],
    1377                                    GetDescription (ComSafeArrayAsOutParam (retTypes),
    1378                                                    ComSafeArrayAsOutParam (retRefValues),
    1379                                                    ComSafeArrayAsOutParam (retOrigValues),
    1380                                                    ComSafeArrayAsOutParam (retAutoValues),
    1381                                                    ComSafeArrayAsOutParam (retConfiguration)));
    1382 
    1383                 RTPrintf ("VirtualSystemDescription:\n");
     1371                CHECK_ERROR_BREAK(retVSD[i],
     1372                                  GetDescription(ComSafeArrayAsOutParam(retTypes),
     1373                                                 ComSafeArrayAsOutParam(retRefValues),
     1374                                                 ComSafeArrayAsOutParam(retOrigValues),
     1375                                                 ComSafeArrayAsOutParam(retAutoValues),
     1376                                                 ComSafeArrayAsOutParam(retConfiguration)));
     1377
     1378                RTPrintf("VirtualSystemDescription:\n");
    13841379                for (unsigned a = 0; a < retTypes.size(); ++a)
    13851380                {
    1386                     RTPrintf (" %d %ls %ls %ls\n",
    1387                             retTypes [a],
    1388                             Bstr (retOrigValues [a]).raw(),
    1389                             Bstr (retAutoValues [a]).raw(),
    1390                             Bstr (retConfiguration [a]).raw());
     1381                    RTPrintf(" %d %ls %ls %ls\n",
     1382                            retTypes[a],
     1383                            Bstr(retOrigValues[a]).raw(),
     1384                            Bstr(retAutoValues[a]).raw(),
     1385                            Bstr(retConfiguration[a]).raw());
    13911386                }
    13921387                /* Show warnings from interpret */
    13931388                com::SafeArray<BSTR> retWarnings;
    1394                 CHECK_ERROR_BREAK (retVSD [i],
    1395                                    GetWarnings(ComSafeArrayAsOutParam (retWarnings)));
     1389                CHECK_ERROR_BREAK(retVSD[i],
     1390                                  GetWarnings(ComSafeArrayAsOutParam(retWarnings)));
    13961391                if (retWarnings.size() > 0)
    13971392                {
    1398                     RTPrintf ("The following warnings occurs on interpret:\n");
     1393                    RTPrintf("The following warnings occurs on interpret:\n");
    13991394                    for (unsigned r = 0; r < retWarnings.size(); ++r)
    1400                         RTPrintf ("%ls\n", Bstr (retWarnings [r]).raw());
    1401                     RTPrintf ("\n");
     1395                        RTPrintf("%ls\n", Bstr(retWarnings[r]).raw());
     1396                    RTPrintf("\n");
    14021397                }
    14031398            }
    1404             RTPrintf ("\n");
    1405         }
    1406         RTPrintf ("Try to import the appliance ...\n");
     1399            RTPrintf("\n");
     1400        }
     1401        RTPrintf("Try to import the appliance ...\n");
    14071402        ComPtr<IProgress> progress;
    1408         CHECK_ERROR_BREAK (appliance,
    1409                            ImportMachines (progress.asOutParam()));
    1410         CHECK_ERROR (progress, WaitForCompletion (-1));
     1403        CHECK_ERROR_BREAK(appliance,
     1404                          ImportMachines(progress.asOutParam()));
     1405        CHECK_ERROR(progress, WaitForCompletion(-1));
    14111406        if (SUCCEEDED(rc))
    14121407        {
    14131408            /* Check if the import was successfully */
    1414             progress->COMGETTER (ResultCode)(&rc);
    1415             if (FAILED (rc))
     1409            progress->COMGETTER(ResultCode)(&rc);
     1410            if (FAILED(rc))
    14161411            {
    1417                 com::ProgressErrorInfo info (progress);
     1412                com::ProgressErrorInfo info(progress);
    14181413                if (info.isBasicAvailable())
    1419                     RTPrintf ("Error: failed to import appliance. Error message: %lS\n", info.getText().raw());
     1414                    RTPrintf("Error: failed to import appliance. Error message: %lS\n", info.getText().raw());
    14201415                else
    1421                     RTPrintf ("Error: failed to import appliance. No error message available!\n");
     1416                    RTPrintf("Error: failed to import appliance. No error message available!\n");
    14221417            }else
    1423                 RTPrintf ("Successfully imported the appliance.\n");
     1418                RTPrintf("Successfully imported the appliance.\n");
    14241419        }
    14251420
    14261421    }
    14271422    while (FALSE);
    1428     RTPrintf ("\n");
    1429 #endif
    1430 
    1431     RTPrintf ("Press enter to release Session and VirtualBox instances...");
     1423    RTPrintf("\n");
     1424#endif
     1425
     1426    RTPrintf("Press enter to release Session and VirtualBox instances...");
    14321427    getchar();
    14331428
    … …  
    14421437    com::Shutdown();
    14431438
    1444     RTPrintf ("tstAPI FINISHED.\n");
     1439    RTPrintf("tstAPI FINISHED.\n");
    14451440
    14461441    return rc;
    … …  
    14481443
    14491444#ifdef VBOX_WITH_RESOURCE_USAGE_API
    1450 static void queryMetrics (ComPtr<IVirtualBox> aVirtualBox,
    1451                           ComPtr<IPerformanceCollector> collector,
    1452                           ComSafeArrayIn (IUnknown *, objects))
     1445static void queryMetrics(ComPtr<IVirtualBox> aVirtualBox,
     1446                         ComPtr<IPerformanceCollector> collector,
     1447                         ComSafeArrayIn(IUnknown *, objects))
    14531448{
    14541449    HRESULT rc;
    … …  
    14561451    //Bstr metricNames[] = { L"CPU/Load/User:avg,CPU/Load/System:avg,CPU/Load/Idle:avg,RAM/Usage/Total,RAM/Usage/Used:avg" };
    14571452    Bstr metricNames[] = { L"*" };
    1458     com::SafeArray<BSTR> metrics (1);
    1459     metricNames[0].cloneTo(&metrics [0]);
     1453    com::SafeArray<BSTR> metrics(1);
     1454    metricNames[0].cloneTo(&metrics[0]);
    14601455    com::SafeArray<BSTR>          retNames;
    14611456    com::SafeIfaceArray<IUnknown> retObjects;
    … …  
    14661461    com::SafeArray<ULONG>         retLengths;
    14671462    com::SafeArray<LONG>          retData;
    1468     CHECK_ERROR (collector, QueryMetricsData(ComSafeArrayAsInParam(metrics),
    1469                                              ComSafeArrayInArg(objects),
    1470                                              ComSafeArrayAsOutParam(retNames),
    1471                                              ComSafeArrayAsOutParam(retObjects),
    1472                                              ComSafeArrayAsOutParam(retUnits),
    1473                                              ComSafeArrayAsOutParam(retScales),
    1474                                              ComSafeArrayAsOutParam(retSequenceNumbers),
    1475                                              ComSafeArrayAsOutParam(retIndices),
    1476                                              ComSafeArrayAsOutParam(retLengths),
    1477                                              ComSafeArrayAsOutParam(retData)) );
     1463    CHECK_ERROR(collector, QueryMetricsData(ComSafeArrayAsInParam(metrics),
     1464                                            ComSafeArrayInArg(objects),
     1465                                            ComSafeArrayAsOutParam(retNames),
     1466                                            ComSafeArrayAsOutParam(retObjects),
     1467                                            ComSafeArrayAsOutParam(retUnits),
     1468                                            ComSafeArrayAsOutParam(retScales),
     1469                                            ComSafeArrayAsOutParam(retSequenceNumbers),
     1470                                            ComSafeArrayAsOutParam(retIndices),
     1471                                            ComSafeArrayAsOutParam(retLengths),
     1472                                            ComSafeArrayAsOutParam(retData)));
    14781473    RTPrintf("Object     Metric               Values\n"
    14791474             "---------- -------------------- --------------------------------------------\n");

  • trunk/src/VBox/Main/testcase/tstOVF.cpp

    r31333 r32718  
    9494
    9595    ComPtr<IProgress> pProgress;
    96     rc = pAppl->Read(Bstr(szAbsOVF), pProgress.asOutParam());
     96    rc = pAppl->Read(Bstr(szAbsOVF).raw(), pProgress.asOutParam());
    9797    if (FAILED(rc)) throw MyError(rc, "Appliance::Read() failed\n");
    9898    rc = pProgress->WaitForCompletion(-1);
    … …  
    345345            Bstr bstrUUID(uuid.toUtf16());
    346346            ComPtr<IMachine> pMachine;
    347             rc = pVirtualBox->GetMachine(bstrUUID, pMachine.asOutParam());
     347            rc = pVirtualBox->GetMachine(bstrUUID.raw(), pMachine.asOutParam());
    348348            if (FAILED(rc)) throw MyError(rc, "VirtualBox::FindMachine() failed\n");
    349349

  • trunk/src/VBox/Main/webservice/websrv-cpp.xsl

    r31333 r32718  
    769769      <xsl:when test="$attrdir='in'">
    770770        <xsl:value-of select="concat('comcall_', $varprefix, @name)" />
     771        <xsl:if test="$attrtype='wstring' or $attrtype='uuid'">
     772          <xsl:text>.raw()</xsl:text>
     773        </xsl:if>
    771774      </xsl:when>
    772775      <xsl:when test="$attrdir='return'">
    … …  
    797800          <xsl:otherwise>
    798801            <xsl:value-of select="concat('comcall_', $varprefix, @name)" />
     802            <xsl:if test="@type='wstring' or @type='uuid'">
     803              <xsl:text>.raw()</xsl:text>
     804            </xsl:if>
    799805          </xsl:otherwise>
    800806        </xsl:choose>
Note: See TracChangeset for help on using the changeset viewer.

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