VirtualBox

Changeset 94965 in vbox


Ignore:
Timestamp:
May 9, 2022 3:03:17 PM (3 years ago)
Author:
vboxsync
Message:

Main/src-client/RemoteUSBBackend.cpp: Adjust to the new rules wrt. to rc -> hrc,vrc usage, ​bugref:10223

File:
1 edited

Legend:

Unmodified
Added
Removed
  • trunk/src/VBox/Main/src-client/RemoteUSBBackend.cpp

    r93115 r94965  
    125125static void requestDevice(REMOTEUSBDEVICE *pDevice)
    126126{
    127     int rc = RTCritSectEnter(&pDevice->critsect);
    128     AssertRC(rc);
     127    int vrc = RTCritSectEnter(&pDevice->critsect);
     128    AssertRC(vrc);
    129129}
    130130
     
    158158{
    159159    RT_NOREF(u32ClientId);
    160     int rc = VINF_SUCCESS;
     160    int vrc = VINF_SUCCESS;
    161161
    162162    LogFlow(("USBClientResponseCallback: id = %d, pv = %p, code = %d, pvRet = %p, cbRet = %d\n",
     
    169169        case VRDE_USB_REQ_DEVICE_LIST:
    170170        {
    171             rc = pThis->saveDeviceList(pvRet, cbRet);
     171            vrc = pThis->saveDeviceList(pvRet, cbRet);
    172172        } break;
    173173
     
    178178                VRDEUSBREQNEGOTIATERET *pret = (VRDEUSBREQNEGOTIATERET *)pvRet;
    179179
    180                 rc = pThis->negotiateResponse(pret, cbRet);
     180                vrc = pThis->negotiateResponse(pret, cbRet);
    181181            }
    182182            else
     
    185185                     pvRet, cbRet, sizeof(VRDEUSBREQNEGOTIATERET)));
    186186
    187                 rc = VERR_INVALID_PARAMETER;
     187                vrc = VERR_INVALID_PARAMETER;
    188188            }
    189189        } break;
     
    191191        case VRDE_USB_REQ_REAP_URB:
    192192        {
    193             rc = pThis->reapURB(pvRet, cbRet);
    194 
    195             LogFlow(("USBClientResponseCallback: reap URB, rc = %Rrc.\n", rc));
     193            vrc = pThis->reapURB(pvRet, cbRet);
     194
     195            LogFlow(("USBClientResponseCallback: reap URB, rc = %Rrc.\n", vrc));
    196196        } break;
    197197
     
    226226                    {
    227227                        Log(("USBClientResponseCallback: WARNING: invalid device id %08X.\n", pret->id));
    228                         rc = VERR_INVALID_PARAMETER;
     228                        vrc = VERR_INVALID_PARAMETER;
    229229                    }
    230230                    else
     
    248248    }
    249249
    250     return rc;
     250    return vrc;
    251251}
    252252
     
    258258{
    259259    RT_NOREF(cbAddress);
    260     int rc = VINF_SUCCESS;
     260    int vrc = VINF_SUCCESS;
    261261
    262262    RemoteUSBBackend *pThis = (RemoteUSBBackend *)pInstance;
     
    266266    if (!pDevice)
    267267    {
    268         rc = VERR_NO_MEMORY;
     268        vrc = VERR_NO_MEMORY;
    269269    }
    270270    else
     
    277277        {
    278278            AssertFailed();
    279             rc = VERR_INVALID_PARAMETER;
     279            vrc = VERR_INVALID_PARAMETER;
    280280        }
    281281        else
     
    285285            pDevice->fWokenUp = false;
    286286
    287             rc = RTCritSectInit(&pDevice->critsect);
    288             AssertRC(rc);
    289 
    290             if (RT_SUCCESS(rc))
     287            vrc = RTCritSectInit(&pDevice->critsect);
     288            AssertRC(vrc);
     289
     290            if (RT_SUCCESS(vrc))
    291291            {
    292292                pDevice->id = RTStrToUInt32(&pszAddress[REMOTE_USB_BACKEND_PREFIX_LEN]);
     
    304304                    {
    305305                        AssertFailed();
    306                         rc = VERR_INVALID_PARAMETER;
     306                        vrc = VERR_INVALID_PARAMETER;
    307307                    }
    308308                }
     
    310310                {
    311311                    AssertFailed();
    312                     rc = VERR_INVALID_PARAMETER;
     312                    vrc = VERR_INVALID_PARAMETER;
    313313                }
    314314
    315                 if (RT_SUCCESS(rc))
     315                if (RT_SUCCESS(vrc))
    316316                {
    317317                    VRDE_USB_REQ_OPEN_PARM parm;
     
    326326    }
    327327
    328     if (RT_SUCCESS(rc))
     328    if (RT_SUCCESS(vrc))
    329329    {
    330330        *ppDevice = pDevice;
     
    337337    }
    338338
    339     return rc;
     339    return vrc;
    340340}
    341341
     
    529529                                        uint32_t u32Len, void *pvData, void *pvURB, PREMOTEUSBQURB *ppRemoteURB)
    530530{
    531     int rc = VINF_SUCCESS;
     531    int vrc = VINF_SUCCESS;
    532532
    533533#ifdef DEBUG_sunlover
     
    551551    if (qurb == NULL)
    552552    {
    553         rc = VERR_NO_MEMORY;
     553        vrc = VERR_NO_MEMORY;
    554554        goto l_leave;
    555555    }
     
    577577        {
    578578            AssertFailed();
    579             rc = VERR_INVALID_PARAMETER;
     579            vrc = VERR_INVALID_PARAMETER;
    580580            goto l_leave;
    581581        }
     
    602602        case VUSBXFERTYPE_INTR: parm.type = VRDE_USB_TRANSFER_TYPE_INTR; break;
    603603        case VUSBXFERTYPE_MSG:  parm.type = VRDE_USB_TRANSFER_TYPE_MSG;  break;
    604         default: AssertFailed(); rc = VERR_INVALID_PARAMETER; goto l_leave;
     604        default: AssertFailed(); vrc = VERR_INVALID_PARAMETER; goto l_leave;
    605605    }
    606606
     
    612612        case VUSB_DIRECTION_IN:    parm.direction = VRDE_USB_DIRECTION_IN;    break;
    613613        case VUSB_DIRECTION_OUT:   parm.direction = VRDE_USB_DIRECTION_OUT;   break;
    614         default: AssertFailed(); rc = VERR_INVALID_PARAMETER; goto l_leave;
     614        default: AssertFailed(); vrc = VERR_INVALID_PARAMETER; goto l_leave;
    615615    }
    616616
     
    658658
    659659l_leave:
    660     if (RT_FAILURE(rc))
     660    if (RT_FAILURE(vrc))
    661661    {
    662662        qurbFree(qurb);
    663663    }
    664664
    665     return rc;
     665    return vrc;
    666666}
    667667
     
    672672                                       uint32_t *pu32Len, uint32_t *pu32Err)
    673673{
    674     int rc = VINF_SUCCESS;
     674    int vrc = VINF_SUCCESS;
    675675
    676676    LogFlow(("RemoteUSBBackend::iface_ReapURB %d ms\n", u32Millies));
     
    794794    }
    795795
    796     return rc;
     796    return vrc;
    797797}
    798798
     
    976976    Assert(server);
    977977
    978     int rc = RTCritSectInit(&mCritsect);
    979 
    980     if (RT_FAILURE(rc))
     978    int vrc = RTCritSectInit(&mCritsect);
     979
     980    if (RT_FAILURE(vrc))
    981981    {
    982982        AssertFailed();
     
    10151015int RemoteUSBBackend::negotiateResponse(const VRDEUSBREQNEGOTIATERET *pret, uint32_t cbRet)
    10161016{
    1017     int rc = VINF_SUCCESS;
     1017    int vrc = VINF_SUCCESS;
    10181018
    10191019    Log(("RemoteUSBBackend::negotiateResponse: flags = %02X.\n", pret->flags));
     
    10481048            {
    10491049                LogRel(("VRDP: ERROR: unsupported remote USB protocol client version %d.\n", pret2->u32Version));
    1050                 rc = VERR_NOT_SUPPORTED;
     1050                vrc = VERR_NOT_SUPPORTED;
    10511051            }
    10521052        }
     
    10541054        {
    10551055            LogRel(("VRDP: ERROR: invalid remote USB negotiate request packet size %d.\n", cbRet));
    1056             rc = VERR_NOT_SUPPORTED;
     1056            vrc = VERR_NOT_SUPPORTED;
    10571057        }
    10581058    }
     
    10631063    }
    10641064
    1065     if (RT_SUCCESS(rc))
     1065    if (RT_SUCCESS(vrc))
    10661066    {
    10671067        LogRel(("VRDP: remote USB protocol version %d.\n", mClientVersion));
     
    10791079            {
    10801080                LogRel(("VRDP: ERROR: invalid remote USB negotiate request packet size %d.\n", cbRet));
    1081                 rc = VERR_NOT_SUPPORTED;
     1081                vrc = VERR_NOT_SUPPORTED;
    10821082            }
    10831083        }
     
    10861086    }
    10871087
    1088     return rc;
     1088    return vrc;
    10891089}
    10901090
     
    11141114void RemoteUSBBackend::request(void)
    11151115{
    1116     int rc = RTCritSectEnter(&mCritsect);
    1117     AssertRC(rc);
     1116    int vrc = RTCritSectEnter(&mCritsect);
     1117    AssertRC(vrc);
    11181118}
    11191119
     
    11781178int RemoteUSBBackend::reapURB(const void *pvBody, uint32_t cbBody)
    11791179{
    1180     int rc = VINF_SUCCESS;
     1180    int vrc = VINF_SUCCESS;
    11811181
    11821182    LogFlow(("RemoteUSBBackend::reapURB: pvBody = %p, cbBody = %d\n", pvBody, cbBody));
     
    12061206        {
    12071207            LogFlow(("RemoteUSBBackend::reapURB: WARNING: invalid reply data. Skipping the reply.\n"));
    1208             rc = VERR_INVALID_PARAMETER;
     1208            vrc = VERR_INVALID_PARAMETER;
    12091209            break;
    12101210        }
     
    12151215        {
    12161216            LogFlow(("RemoteUSBBackend::reapURB: WARNING: invalid device id. Skipping the reply.\n"));
    1217             rc = VERR_INVALID_PARAMETER;
     1217            vrc = VERR_INVALID_PARAMETER;
    12181218            break;
    12191219        }
     
    13851385        if (cbBodySize > cbBody)
    13861386        {
    1387             rc = VERR_INVALID_PARAMETER;
     1387            vrc = VERR_INVALID_PARAMETER;
    13881388            break;
    13891389        }
     
    13931393    }
    13941394
    1395     LogFlow(("RemoteUSBBackend::reapURB: returns %Rrc\n", rc));
    1396 
    1397     return rc;
     1395    LogFlow(("RemoteUSBBackend::reapURB: returns %Rrc\n", vrc));
     1396
     1397    return vrc;
    13981398}
    13991399/* vi: set tabstop=4 shiftwidth=4 expandtab: */
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