VirtualBox

Ignore:
Timestamp:
Mar 25, 2010 3:01:21 PM (15 years ago)
Author:
vboxsync
svn:sync-xref-src-repo-rev:
59316
Message:

Additions/x11/VBoxClient: converted logging to release logging (which is opt-in at runtime in guest R3)

Location:
trunk/src/VBox/Additions/x11/VBoxClient
Files:
10 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/VBox/Additions/x11/VBoxClient/clipboard.h

    r25728 r27709  
    9595    int init(void)
    9696    {
    97         LogFlowThisFunc(("\n"));
     97        LogRelFlowFunc(("\n"));
    9898        int rc = mThreadFunction.init();
    9999        if (RT_SUCCESS(rc))
    … …  
    101101        if (RT_SUCCESS(rc))
    102102            mInit = true;
    103         LogFlowThisFunc(("returning %Rrc\n", rc));
     103        LogRelFlowFunc(("returning %Rrc\n", rc));
    104104        return rc;
    105105    }
    … …  
    110110    void uninit(RTMSINTERVAL cMillies = RT_INDEFINITE_WAIT)
    111111    {
    112         LogFlowThisFunc(("\n"));
     112        LogRelFlowFunc(("\n"));
    113113        if (mInit)
    114114            mThread.stop(cMillies, NULL);
    115         LogFlowThisFunc(("returning\n"));
     115        LogRelFlowFunc(("returning\n"));
    116116    }
    117117
    … …  
    121121    ~VBoxGuestClipboard()
    122122    {
    123         LogFlowThisFunc(("\n"));
     123        LogRelFlowFunc(("\n"));
    124124        if (mInit)
    125125            try {
    126126                uninit(2000);
    127127            } catch (...) { }
    128         LogFlowThisFunc(("returning\n"));
     128        LogRelFlowFunc(("returning\n"));
    129129    }
    130130};

  • trunk/src/VBox/Additions/x11/VBoxClient/display.cpp

    r27601 r27709  
    4545    uint32_t fMouseFeatures = 0;
    4646
    47     LogFlowFunc(("testing dynamic resizing\n"));
     47    LogRelFlowFunc(("testing dynamic resizing\n"));
    4848    int iDummy;
    4949    if (!XRRQueryExtension(pDisplay, &iDummy, &iDummy))
    … …  
    5555    /* Log and ignore the return value, as there is not much we can do with
    5656     * it. */
    57     LogFlowFunc(("dynamic resizing: result %Rrc\n", rc));
     57    LogRelFlowFunc(("dynamic resizing: result %Rrc\n", rc));
    5858    /* Enable support for switching between hardware and software cursors */
    59     LogFlowFunc(("enabling relative mouse re-capturing support\n"));
     59    LogRelFlowFunc(("enabling relative mouse re-capturing support\n"));
    6060    rc = VbglR3GetMouseStatus(&fMouseFeatures, NULL, NULL);
    6161    if (RT_SUCCESS(rc))
    … …  
    7979                             | VMMDEV_MOUSE_GUEST_NEEDS_HOST_CURSOR);
    8080    }
    81     LogFlowFunc(("mouse re-capturing support: result %Rrc\n", rc));
     81    LogRelFlowFunc(("mouse re-capturing support: result %Rrc\n", rc));
    8282    return VINF_SUCCESS;
    8383}
    … …  
    8686{
    8787    uint32_t fMouseFeatures = 0;
    88     LogFlowFunc(("\n"));
     88    LogRelFlowFunc(("\n"));
    8989    VbglR3CtlFilterMask(0,   VMMDEV_EVENT_DISPLAY_CHANGE_REQUEST
    9090                           | VMMDEV_EVENT_MOUSE_CAPABILITIES_CHANGED);
    … …  
    9393        VbglR3SetMouseStatus(  fMouseFeatures
    9494                             | VMMDEV_MOUSE_GUEST_NEEDS_HOST_CURSOR);
    95     LogFlowFunc(("returning\n"));
     95    LogRelFlowFunc(("returning\n"));
    9696}
    9797
    … …  
    119119    pConfig = XRRGetScreenInfo(pDisplay, DefaultRootWindow(pDisplay));
    120120    /* Reset the current mode */
    121     LogFlowFunc(("Setting size %ux%u\n", cx, cy));
     121    LogRelFlowFunc(("Setting size %ux%u\n", cx, cy));
    122122    if (pConfig)
    123123    {
    … …  
    130130            unsigned uThisDist =   VBCL_SQUARE(pSizes[i].width - cx)
    131131                                 + VBCL_SQUARE(pSizes[i].height - cy);
    132             LogFlowFunc(("Found size %dx%d, distance %u\n", pSizes[i].width,
     132            LogRelFlowFunc(("Found size %dx%d, distance %u\n", pSizes[i].width,
    133133                         pSizes[i].height, uThisDist));
    134134#undef VBCL_SQUARE
    … …  
    143143            Time config_timestamp = 0;
    144144            XRRConfigTimes(pConfig, &config_timestamp);
    145             LogFlowFunc(("Setting new size %d\n", iMode));
     145            LogRelFlowFunc(("Setting new size %d\n", iMode));
    146146            XRRSetScreenConfig(pDisplay, pConfig,
    147147                               DefaultRootWindow(pDisplay), iMode,
    … …  
    161161static int runDisplay(Display *pDisplay)
    162162{
    163     LogFlowFunc(("\n"));
     163    LogRelFlowFunc(("\n"));
    164164    Cursor hClockCursor = XCreateFontCursor(pDisplay, XC_watch);
    165165    Cursor hArrowCursor = XCreateFontCursor(pDisplay, XC_left_ptr);
    … …  
    199199        }
    200200    }
    201     LogFlowFunc(("returning VINF_SUCCESS\n"));
     201    LogRelFlowFunc(("returning VINF_SUCCESS\n"));
    202202    return VINF_SUCCESS;
    203203}

  • trunk/src/VBox/Additions/x11/VBoxClient/hostversion.cpp

    r26505 r27709  
    5252        if (conn == NULL)
    5353        {
    54             LogFlow(("Could not retrieve D-BUS session bus!\n"));
     54            LogRelFlowFunc(("Could not retrieve D-BUS session bus!\n"));
    5555            rc = VERR_INVALID_HANDLE;
    5656        }
    … …  
    6363            if (msg == NULL)
    6464            {
    65                 Log(("Could not create D-BUS message!\n"));
     65                LogRel(("Could not create D-BUS message!\n"));
    6666                rc = VERR_INVALID_HANDLE;
    6767            }
    … …  
    109109            if (dbus_error_is_set(&err))
    110110            {
    111                 Log(("D-BUS returned an error while sending the notification: %s", err.message));
     111                LogRel(("D-BUS returned an error while sending the notification: %s", err.message));
    112112            }
    113113            else if (reply)
    … …  
    133133    {
    134134        int rc;
    135         LogFlowFunc(("\n"));
     135        LogRelFlowFunc(("\n"));
    136136
    137137        /* Because we need desktop notifications to be displayed, wait
    … …  
    154154            rc = VbglR3GuestPropConnect(&uGuestPropSvcClientID);
    155155            if (RT_FAILURE(rc))
    156                 Log(("Cannot connect to guest property service! rc = %Rrc\n", rc));
     156                LogRel(("Cannot connect to guest property service! rc = %Rrc\n", rc));
    157157        }
    158158
    … …  
    179179                    LogRel(("VBoxClient: VirtualBox Guest Additions update available!"));
    180180                    if (RT_FAILURE(rc))
    181                         Log(("VBoxClient: Could not show version notifier tooltip! rc = %d\n", rc));
     181                        LogRel(("VBoxClient: Could not show version notifier tooltip! rc = %d\n", rc));
    182182                }
    183183
    … …  
    191191        }
    192192# endif /* VBOX_WITH_GUEST_PROPS */
    193         LogFlowFunc(("returning %Rrc\n", rc));
     193        LogRelFlowFunc(("returning %Rrc\n", rc));
    194194        return rc;
    195195    }

  • trunk/src/VBox/Additions/x11/VBoxClient/main.cpp

    r25954 r27709  
    4242#include "VBoxClient.h"
    4343
    44 #define TRACE RTPrintf("%s: %d\n", __PRETTY_FUNCTION__, __LINE__); Log(("%s: %d\n", __PRETTY_FUNCTION__, __LINE__))
     44#define TRACE RTPrintf("%s: %d\n", __PRETTY_FUNCTION__, __LINE__); LogRel(("%s: %d\n", __PRETTY_FUNCTION__, __LINE__))
    4545
    4646static int (*gpfnOldIOErrorHandler)(Display *) = NULL;
    … …  
    7676void vboxClientSignalHandler(int cSignal)
    7777{
    78     Log(("VBoxClient: terminated with signal %d\n", cSignal));
     78    LogRel(("VBoxClient: terminated with signal %d\n", cSignal));
    7979    /** Disable seamless mode */
    8080    RTPrintf(("VBoxClient: terminating...\n"));
    … …  
    100100static int vboxClientXLibIOErrorHandler(Display *pDisplay)
    101101{
    102     Log(("VBoxClient: a fatal guest X Window error occurred.  This may just mean that the Window system was shut down while the client was still running.\n"));
     102    LogRel(("VBoxClient: a fatal guest X Window error occurred.  This may just mean that the Window system was shut down while the client was still running.\n"));
    103103    VBoxClient::CleanUp();
    104104    return 0;  /* We should never reach this. */
    … …  
    113113    struct sigaction sigAction;
    114114
    115     LogFlowFunc(("\n"));
     115    LogRelFlowFunc(("\n"));
    116116    sigAction.sa_handler = vboxClientSignalHandler;
    117117    sigemptyset(&sigAction.sa_mask);
    … …  
    126126    sigaction(SIGUSR1, &sigAction, NULL);
    127127    sigaction(SIGUSR2, &sigAction, NULL);
    128     LogFlowFunc(("returning\n"));
     128    LogRelFlowFunc(("returning\n"));
    129129}
    130130
    … …  
    224224        {
    225225            RTPrintf("VBoxClient: failed to daemonize.  Exiting.\n");
    226             Log(("VBoxClient: failed to daemonize.  Exiting.\n"));
     226            LogRel(("VBoxClient: failed to daemonize.  Exiting.\n"));
    227227# ifdef DEBUG
    228228            RTPrintf("Error %Rrc\n", rc);
    … …  
    237237    {
    238238        RTPrintf("VBoxClient: failed to get home directory, rc=%Rrc.  Exiting.\n", rc);
    239         Log(("VBoxClient: failed to get home directory, rc=%Rrc.  Exiting.\n", rc));
     239        LogRel(("VBoxClient: failed to get home directory, rc=%Rrc.  Exiting.\n", rc));
    240240        return 1;
    241241    }
    … …  
    244244    {
    245245        RTPrintf("VBoxClient: RTPathAppend failed with rc=%Rrc.  Exiting.\n", rc);
    246         Log(("VBoxClient: RTPathAppend failed with rc=%Rrc.  Exiting.\n", rc));
     246        LogRel(("VBoxClient: RTPathAppend failed with rc=%Rrc.  Exiting.\n", rc));
    247247        return 1;
    248248    }
    … …  
    252252    {
    253253        RTPrintf("Failed to connect to the VirtualBox kernel service\n");
    254         Log(("Failed to connect to the VirtualBox kernel service\n"));
     254        LogRel(("Failed to connect to the VirtualBox kernel service\n"));
    255255        return 1;
    256256    }
    … …  
    258258    {
    259259        RTPrintf("Failed to create a pidfile.  Exiting.\n");
    260         Log(("Failed to create a pidfile.  Exiting.\n"));
     260        LogRel(("Failed to create a pidfile.  Exiting.\n"));
    261261        VbglR3Term();
    262262        return 1;

  • trunk/src/VBox/Additions/x11/VBoxClient/seamless-host.cpp

    r25728 r27709  
    3838    int rc = VERR_NOT_SUPPORTED;
    3939
    40     LogFlowThisFunc(("\n"));
     40    LogRelFlowFunc(("\n"));
    4141    if (mRunning)  /* Assertion */
    4242    {
    … …  
    5252    if (RT_SUCCESS(rc))
    5353    {
    54         Log(("VBoxClient: enabled seamless capability on host.\n"));
     54        LogRel(("VBoxClient: enabled seamless capability on host.\n"));
    5555        rc = mThread.start();
    5656        if (RT_SUCCESS(rc))
    … …  
    6666    if (RT_FAILURE(rc))
    6767    {
    68         Log(("VBoxClient (seamless): failed to enable seamless capability on host, rc=%Rrc\n", rc));
     68        LogRel(("VBoxClient (seamless): failed to enable seamless capability on host, rc=%Rrc\n", rc));
    6969    }
    70     LogFlowThisFunc(("returning %Rrc\n", rc));
     70    LogRelFlowFunc(("returning %Rrc\n", rc));
    7171    return rc;
    7272}
    … …  
    7575void VBoxGuestSeamlessHost::stop(RTMSINTERVAL cMillies /* = RT_INDEFINITE_WAIT */)
    7676{
    77     LogFlowThisFunc(("returning\n"));
     77    LogRelFlowFunc(("returning\n"));
    7878    if (!mRunning)  /* Assertion */
    7979    {
    … …  
    8585    VbglR3SeamlessSetCap(false);
    8686    mRunning = false;
    87     LogFlowThisFunc(("returning\n"));
     87    LogRelFlowFunc(("returning\n"));
    8888}
    8989
    … …  
    9797    VMMDevSeamlessMode newMode = VMMDev_Seamless_Disabled;
    9898
    99     LogFlowThisFunc(("\n"));
     99    LogRelFlowFunc(("\n"));
    100100    int rc = VbglR3SeamlessWaitEvent(&newMode);
    101101    if (RT_SUCCESS(rc))
    … …  
    129129    else
    130130    {
    131         LogFunc(("VbglR3SeamlessWaitEvent returned %Rrc (VBoxClient)\n", rc));
     131        LogRelFunc(("VbglR3SeamlessWaitEvent returned %Rrc (VBoxClient)\n", rc));
    132132    }
    133     LogFlowThisFunc(("returning %Rrc\n", rc));
     133    LogRelFlowFunc(("returning %Rrc\n", rc));
    134134    return rc;
    135135}
    … …  
    140140void VBoxGuestSeamlessHost::updateRects(std::auto_ptr<std::vector<RTRECT> > pRects)
    141141{
    142     LogFlowThisFunc(("\n"));
     142    LogRelFlowFunc(("\n"));
    143143    if (0 == pRects.get())  /* Assertion */
    144144    {
    … …  
    147147    }
    148148    VbglR3SeamlessSendRects(pRects.get()->size(), pRects.get()->empty() ? NULL : &pRects.get()->front());
    149     LogFlowThisFunc(("returning\n"));
     149    LogRelFlowFunc(("returning\n"));
    150150}
    151151
    … …  
    158158int VBoxGuestSeamlessHostThread::threadFunction(VBoxGuestThread *pThread)
    159159{
    160     LogFlowThisFunc(("\n"));
     160    LogRelFlowFunc(("\n"));
    161161    if (0 != mHost)
    162162    {
    … …  
    172172        }
    173173    }
    174     LogFlowThisFunc(("returning VINF_SUCCESS\n"));
     174    LogRelFlowFunc(("returning VINF_SUCCESS\n"));
    175175    return VINF_SUCCESS;
    176176}
    … …  
    181181void VBoxGuestSeamlessHostThread::stop(void)
    182182{
    183     LogFlowThisFunc(("\n"));
     183    LogRelFlowFunc(("\n"));
    184184    if (0 != mHost)
    185185    {
    … …  
    196196        }
    197197    }
    198     LogFlowThisFunc(("returning\n"));
     198    LogRelFlowFunc(("returning\n"));
    199199}

  • trunk/src/VBox/Additions/x11/VBoxClient/seamless-host.h

    r25728 r27709  
    126126    int init(VBoxGuestSeamlessObserver *pObserver)
    127127    {
    128         LogFlowThisFunc(("\n"));
     128        LogRelFlowFunc(("\n"));
    129129        if (mObserver != 0)  /* Assertion */
    130130        {
    … …  
    133133        }
    134134        mObserver = pObserver;
    135         LogFlowThisFunc(("returning VINF_SUCCESS\n"));
     135        LogRelFlowFunc(("returning VINF_SUCCESS\n"));
    136136        return VINF_SUCCESS;
    137137    }
    … …  
    168168    ~VBoxGuestSeamlessHost()
    169169    {
    170         LogFlowThisFunc(("\n"));
     170        LogRelFlowFunc(("\n"));
    171171        if (mRunning)  /* Assertion */
    172172        {
    … …  
    178178            catch(...) {}
    179179        }
    180         LogFlowThisFunc(("returning\n"));
     180        LogRelFlowFunc(("returning\n"));
    181181    }
    182182};

  • trunk/src/VBox/Additions/x11/VBoxClient/seamless-x11.cpp

    r21940 r27709  
    4646                                    const char *aPropName, unsigned long *nItems)
    4747{
    48     LogFlowFunc(("\n"));
     48    LogRelFlowFunc(("\n"));
    4949    Atom propNameAtom = XInternAtom (aDpy, aPropName,
    5050                                     True /* only_if_exists */);
    … …  
    6565        return NULL;
    6666
    67     LogFlowFunc(("returning\n"));
     67    LogRelFlowFunc(("returning\n"));
    6868    return propVal;
    6969}
    … …  
    7878    int rc = VINF_SUCCESS;
    7979
    80     LogFlowThisFunc(("\n"));
     80    LogRelFlowFunc(("\n"));
    8181    if (0 != mObserver)  /* Assertion */
    8282    {
    … …  
    9090    }
    9191    mObserver = pObserver;
    92     LogFlowThisFunc(("returning %Rrc\n", rc));
     92    LogRelFlowFunc(("returning %Rrc\n", rc));
    9393    return rc;
    9494}
    … …  
    108108    int error, event;
    109109
    110     LogFlowThisFunc(("\n"));
     110    LogRelFlowFunc(("\n"));
    111111    mSupportsShape = XShapeQueryExtension(mDisplay, &event, &error);
    112112    mEnabled = true;
    113113    monitorClientList();
    114114    rebuildWindowTree();
    115     LogFlowThisFunc(("returning %Rrc\n", rc));
     115    LogRelFlowFunc(("returning %Rrc\n", rc));
    116116    return rc;
    117117}
    … …  
    121121void VBoxGuestSeamlessX11::stop(void)
    122122{
    123     LogFlowThisFunc(("\n"));
     123    LogRelFlowFunc(("\n"));
    124124    mEnabled = false;
    125125    unmonitorClientList();
    126126    freeWindowTree();
    127     LogFlowThisFunc(("returning\n"));
     127    LogRelFlowFunc(("returning\n"));
    128128}
    129129
    130130void VBoxGuestSeamlessX11::monitorClientList(void)
    131131{
    132     LogFlowThisFunc(("called\n"));
     132    LogRelFlowFunc(("called\n"));
    133133    XSelectInput(mDisplay, DefaultRootWindow(mDisplay.get()), SubstructureNotifyMask);
    134134}
    … …  
    136136void VBoxGuestSeamlessX11::unmonitorClientList(void)
    137137{
    138     LogFlowThisFunc(("called\n"));
     138    LogRelFlowFunc(("called\n"));
    139139    XSelectInput(mDisplay, DefaultRootWindow(mDisplay.get()), 0);
    140140}
    … …  
    146146void VBoxGuestSeamlessX11::rebuildWindowTree(void)
    147147{
    148     LogFlowThisFunc(("called\n"));
     148    LogRelFlowFunc(("called\n"));
    149149    freeWindowTree();
    150150    addClients(DefaultRootWindow(mDisplay.get()));
    … …  
    170170    unsigned cChildren;
    171171
    172     LogFlowThisFunc(("\n"));
     172    LogRelFlowFunc(("\n"));
    173173    if (!XQueryTree(mDisplay.get(), hRoot, &hRealRoot, &hParent, &phChildrenRaw, &cChildren))
    174174        return;
    … …  
    176176    for (unsigned i = 0; i < cChildren; ++i)
    177177        addClientWindow(phChildren.get()[i]);
    178     LogFlowThisFunc(("returning\n"));
     178    LogRelFlowFunc(("returning\n"));
    179179}
    180180
    … …  
    182182void VBoxGuestSeamlessX11::addClientWindow(const Window hWin)
    183183{
    184     LogFlowThisFunc(("\n"));
     184    LogRelFlowFunc(("\n"));
    185185    XWindowAttributes winAttrib;
    186186    bool fAddWin = true;
    … …  
    202202                                       &dummyLong)))
    203203    {
    204         LogFlowFunc(("window %lu, client window %lu has no size hints\n",
     204        LogRelFlowFunc(("window %lu, client window %lu has no size hints\n",
    205205                     hWin, hClient));
    206206        fAddWin = false;
    … …  
    212212        bool hasShape = false;
    213213
    214         LogFlowFunc(("adding window %lu, client window %lu\n", hWin,
     214        LogRelFlowFunc(("adding window %lu, client window %lu\n", hWin,
    215215                     hClient));
    216216        if (mSupportsShape)
    … …  
    234234                                winAttrib.width, winAttrib.height, cRects, rects);
    235235    }
    236     LogFlowThisFunc(("returning\n"));
     236    LogRelFlowFunc(("returning\n"));
    237237}
    238238
    … …  
    250250    bool rc = false;
    251251
    252     LogFlowThisFunc(("\n"));
     252    LogRelFlowFunc(("\n"));
    253253    windowTypeRaw = XXGetProperty(mDisplay, hWin, XA_ATOM, WM_TYPE_PROP, &ulCount);
    254254    if (windowTypeRaw != NULL)
    … …  
    259259            rc = true;
    260260    }
    261     LogFlowThisFunc(("returning %s\n", rc ? "true" : "false"));
     261    LogRelFlowFunc(("returning %s\n", rc ? "true" : "false"));
    262262    return rc;
    263263}
    … …  
    270270{
    271271    /* We use post-increment in the operation to prevent the iterator from being invalidated. */
    272     LogFlowThisFunc(("\n"));
     272    LogRelFlowFunc(("\n"));
    273273    for (VBoxGuestWindowList::iterator it = mGuestWindows.begin(); it != mGuestWindows.end();
    274274                 mGuestWindows.removeWindow(it++))
    … …  
    276276        XShapeSelectInput(mDisplay, it->first, 0);
    277277    }
    278     LogFlowThisFunc(("returning\n"));
     278    LogRelFlowFunc(("returning\n"));
    279279}
    280280
    … …  
    289289    XEvent event;
    290290
    291     LogFlowThisFunc(("\n"));
     291    LogRelFlowFunc(("\n"));
    292292    /* Start by sending information about the current window setup to the host.  We do this
    293293       here because we want to send all such information from a single thread. */
    … …  
    314314        break;
    315315    }
    316     LogFlowThisFunc(("returning\n"));
     316    LogRelFlowFunc(("returning\n"));
    317317}
    318318
    … …  
    324324void VBoxGuestSeamlessX11::doConfigureEvent(Window hWin)
    325325{
    326     LogFlowThisFunc(("\n"));
     326    LogRelFlowFunc(("\n"));
    327327    VBoxGuestWindowList::iterator iter;
    328328
    … …  
    352352        mChanged = true;
    353353    }
    354     LogFlowThisFunc(("returning\n"));
     354    LogRelFlowFunc(("returning\n"));
    355355}
    356356
    … …  
    362362void VBoxGuestSeamlessX11::doMapEvent(Window hWin)
    363363{
    364     LogFlowThisFunc(("\n"));
     364    LogRelFlowFunc(("\n"));
    365365    VBoxGuestWindowList::iterator iter;
    366366
    … …  
    371371        mChanged = true;
    372372    }
    373     LogFlowThisFunc(("returning\n"));
     373    LogRelFlowFunc(("returning\n"));
    374374}
    375375
    … …  
    382382void VBoxGuestSeamlessX11::doShapeEvent(Window hWin)
    383383{
    384     LogFlowThisFunc(("\n"));
     384    LogRelFlowFunc(("\n"));
    385385    VBoxGuestWindowList::iterator iter;
    386386
    … …  
    400400        mChanged = true;
    401401    }
    402     LogFlowThisFunc(("returning\n"));
     402    LogRelFlowFunc(("returning\n"));
    403403}
    404404
    … …  
    410410void VBoxGuestSeamlessX11::doUnmapEvent(Window hWin)
    411411{
    412     LogFlowThisFunc(("\n"));
     412    LogRelFlowFunc(("\n"));
    413413    VBoxGuestWindowList::iterator iter;
    414414
    … …  
    419419        mChanged = true;
    420420    }
    421     LogFlowThisFunc(("returning\n"));
     421    LogRelFlowFunc(("returning\n"));
    422422}
    423423
    … …  
    427427std::auto_ptr<std::vector<RTRECT> > VBoxGuestSeamlessX11::getRects(void)
    428428{
    429     LogFlowThisFunc(("\n"));
     429    LogRelFlowFunc(("\n"));
    430430    unsigned cRects = 0;
    431431    std::auto_ptr<std::vector<RTRECT> > apRects(new std::vector<RTRECT>);
    … …  
    471471    }
    472472    mcRects = cRects;
    473     LogFlowThisFunc(("returning\n"));
     473    LogRelFlowFunc(("returning\n"));
    474474    return apRects;
    475475}
    … …  
    484484    bool rc = false;
    485485
    486     LogFlowThisFunc(("\n"));
     486    LogRelFlowFunc(("\n"));
    487487    /* Message contents set to zero. */
    488488    XClientMessageEvent clientMessage = { ClientMessage, 0, 0, 0, 0, 0, 8 };
    … …  
    494494        rc = true;
    495495    }
    496     LogFlowThisFunc(("returning %s\n", rc ? "true" : "false"));
     496    LogRelFlowFunc(("returning %s\n", rc ? "true" : "false"));
    497497    return rc;
    498498}

  • trunk/src/VBox/Additions/x11/VBoxClient/seamless-x11.h

    r21441 r27709  
    146146    bool init(char *name = NULL)
    147147    {
    148         LogFlowThisFunc(("\n"));
     148        LogRelFlowFunc(("\n"));
    149149        mDisplay = XOpenDisplay(name);
    150         LogFlowThisFunc(("returning\n"));
     150        LogRelFlowFunc(("returning\n"));
    151151        return (mDisplay != NULL);
    152152    }
    … …  
    156156    int close(void)
    157157    {
    158         LogFlowThisFunc(("\n"));
     158        LogRelFlowFunc(("\n"));
    159159        int rc = XCloseDisplay(mDisplay);
    160160        mDisplay = NULL;
    161         LogFlowThisFunc(("returning\n"));
     161        LogRelFlowFunc(("returning\n"));
    162162        return rc;
    163163    }
    … …  
    244244                   VBoxGuestX11Pointer<XRectangle> rects)
    245245    {
    246         LogFlowThisFunc(("\n"));
     246        LogRelFlowFunc(("\n"));
    247247        VBoxGuestWinInfo *pInfo = new VBoxGuestWinInfo(isMapped, x, y, w, h, cRects,
    248248                                                       rects);
    249249        mWindows.insert(std::pair<Window, VBoxGuestWinInfo *>(hWin, pInfo));
    250         LogFlowThisFunc(("returning\n"));
     250        LogRelFlowFunc(("returning\n"));
    251251    }
    252252
    253253    void removeWindow(iterator it)
    254254    {
    255         LogFlowThisFunc(("called\n"));
     255        LogRelFlowFunc(("called\n"));
    256256        delete it->second;
    257257        mWindows.erase(it);
    … …  
    260260    void removeWindow(Window hWin)
    261261    {
    262         LogFlowThisFunc(("called\n"));
     262        LogRelFlowFunc(("called\n"));
    263263        removeWindow(find(hWin));
    264264    }

  • trunk/src/VBox/Additions/x11/VBoxClient/seamless.h

    r25728 r27709  
    5959        int rc = VINF_SUCCESS;
    6060
    61         LogFlowThisFunc(("\n"));
     61        LogRelFlowFunc(("\n"));
    6262        rc = mGuest->start();
    6363        if (RT_SUCCESS(rc))
    … …  
    6969            mGuest->stop();
    7070        }
    71         LogFlowThisFunc(("returning %Rrc\n", rc));
     71        LogRelFlowFunc(("returning %Rrc\n", rc));
    7272        return rc;
    7373    }
    … …  
    148148        int rc = VINF_SUCCESS;
    149149
    150         LogFlowThisFunc(("\n"));
     150        LogRelFlowFunc(("\n"));
    151151        if (isInitialised)  /* Assertion */
    152152        {
    … …  
    172172        if (RT_FAILURE(rc))
    173173        {
    174             LogFunc(("returning %Rrc (VBoxClient)\n", rc));
    175         }
    176         LogFlowThisFunc(("returning %Rrc\n", rc));
     174            LogRelFunc(("returning %Rrc (VBoxClient)\n", rc));
     175        }
     176        LogRelFlowFunc(("returning %Rrc\n", rc));
    177177        return rc;
    178178    }
    … …  
    180180    void uninit(RTMSINTERVAL cMillies = RT_INDEFINITE_WAIT)
    181181    {
    182         LogFlowThisFunc(("\n"));
     182        LogRelFlowFunc(("\n"));
    183183        if (isInitialised)
    184184        {
    … …  
    188188            isInitialised = false;
    189189        }
    190         LogFlowThisFunc(("returning\n"));
     190        LogRelFlowFunc(("returning\n"));
    191191    }
    192192

  • trunk/src/VBox/Additions/x11/VBoxClient/thread.cpp

    r25728 r27709  
    3030    int rc = VINF_SUCCESS;
    3131
    32     LogFlowThisFunc(("\n"));
     32    LogRelFlowFunc(("\n"));
    3333    if (NIL_RTTHREAD == mSelf)  /* Assertion */
    3434    {
    … …  
    5050        }
    5151    }
    52     LogFlowThisFunc(("returning %Rrc\n", rc));
     52    LogRelFlowFunc(("returning %Rrc\n", rc));
    5353    return rc;
    5454}
    … …  
    5757VBoxGuestThread::~VBoxGuestThread(void)
    5858{
    59     LogFlowThisFunc(("\n"));
     59    LogRelFlowFunc(("\n"));
    6060    if (NIL_RTTHREAD != mSelf)
    6161    {
    … …  
    6767        catch(...) {}
    6868    }
    69     LogFlowThisFunc(("returning\n"));
     69    LogRelFlowFunc(("returning\n"));
    7070}
    7171
    … …  
    7575    int rc = VINF_SUCCESS;
    7676
    77     LogFlowThisFunc(("returning\n"));
     77    LogRelFlowFunc(("returning\n"));
    7878    if (NIL_RTTHREAD != mSelf)  /* Assertion */
    7979    {
    … …  
    8484    rc = RTThreadCreate(&mSelf, threadFunction, reinterpret_cast<void *>(this),
    8585                          mStack, mType, mFlags, mName);
    86     LogFlowThisFunc(("returning %Rrc\n", rc));
     86    LogRelFlowFunc(("returning %Rrc\n", rc));
    8787    return rc;
    8888}
    … …  
    9999    int rc = VINF_SUCCESS;
    100100
    101     LogFlowFunc(("\n"));
     101    LogRelFlowFunc(("\n"));
    102102    PSELF pSelf = reinterpret_cast<PSELF>(pvUser);
    103103    pSelf->mRunning = true;
    … …  
    117117    }
    118118    pSelf->mRunning = false;
    119     LogFlowFunc(("returning %Rrc\n", rc));
     119    LogRelFlowFunc(("returning %Rrc\n", rc));
    120120    return rc;
    121121}
Note: See TracChangeset for help on using the changeset viewer.

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