コード例 #1
0
void
IPDLUnitTestThreadChild::Init()
{
    MozillaChildThread::Init();
    IPDLUnitTestChildInit(channel(), GetParentProcessHandle(), owner_loop());
}
コード例 #2
0
//-----------------------------------------------------------------------------
// Function:    PNMEventHandler
// Purpose:     Registers for all event types and prints out the event data
// Parameters:  None
//
HRESULT EventHandler()
{
    HPEEREVENT            hPeerEvent = NULL;
    HRESULT               hr = S_OK;
    PEER_COLLAB_EVENT_REGISTRATION  eventReg[11] = {0};
    HANDLE hEvent[2];
    HANDLE hParentHandle = NULL;

    hr = GetParentProcessHandle(&hParentHandle);

    if (FAILED(hr))
    {
        printf("Failed to get parent process handle.  Aborting event printing process\n");
        hr = E_FAIL;
        goto exit;
    }

    hEvent[0] = CreateEvent(NULL, FALSE, FALSE, NULL);
    hEvent[1] = hParentHandle;

    eventReg[0].eventType = PEER_EVENT_WATCHLIST_CHANGED;
    eventReg[1].eventType = PEER_EVENT_ENDPOINT_CHANGED;
    eventReg[2].eventType = PEER_EVENT_ENDPOINT_PRESENCE_CHANGED;
    eventReg[3].eventType = PEER_EVENT_ENDPOINT_APPLICATION_CHANGED;
    eventReg[4].eventType = PEER_EVENT_ENDPOINT_OBJECT_CHANGED;
    eventReg[5].eventType = PEER_EVENT_MY_ENDPOINT_CHANGED;
    eventReg[6].eventType = PEER_EVENT_MY_PRESENCE_CHANGED;
    eventReg[7].eventType = PEER_EVENT_MY_APPLICATION_CHANGED;
    eventReg[8].eventType = PEER_EVENT_MY_OBJECT_CHANGED;
    eventReg[9].eventType = PEER_EVENT_PEOPLE_NEAR_ME_CHANGED;
    eventReg[10].eventType = PEER_EVENT_REQUEST_STATUS_CHANGED;

    // Register to be notified when the request finishes  
    hr = PeerCollabRegisterEvent(hEvent[0], celems(eventReg), eventReg, &hPeerEvent);  

    if (SUCCEEDED(hr))
    {
        while (WaitForMultipleObjects(2, hEvent, FALSE, INFINITE) == WAIT_OBJECT_0)
        {
            PEER_COLLAB_EVENT_DATA *pEventData = NULL;

            // retrieve all event data 
            while (PeerCollabGetEventData(hPeerEvent, &pEventData) == S_OK)
            {
                switch(pEventData->eventType)
                {
                    case PEER_EVENT_WATCHLIST_CHANGED:
                        wprintf(L"PEER_EVENT_WATCHLIST_CHANGED event signalled\n");
                        break;

                    case PEER_EVENT_ENDPOINT_CHANGED:
                        wprintf(L"PEER_EVENT_ENDPOINT_CHANGED\n");
                        break;

                    case PEER_EVENT_ENDPOINT_PRESENCE_CHANGED:
                        wprintf(L"PEER_EVENT_ENDPOINT_PRESENCE_CHANGED event signalled\n");
                        break;

                    case PEER_EVENT_ENDPOINT_APPLICATION_CHANGED:
                        wprintf(L"PEER_EVENT_ENDPOINT_APPLICATION_CHANGED event signalled\n");
                        break;

                    case PEER_EVENT_ENDPOINT_OBJECT_CHANGED:
                        wprintf(L"PEER_EVENT_ENDPOINT_OBJECT_CHANGED event signalled\n");
                        break;

                    case PEER_EVENT_MY_ENDPOINT_CHANGED:
                        wprintf(L"PEER_EVENT_MY_ENDPOINT_CHANGED event signalled\n");
                        break;

                    case PEER_EVENT_MY_PRESENCE_CHANGED:
                        wprintf(L"PEER_EVENT_MY_PRESENCE_CHANGED event signalled\n");
                        break;

                    case PEER_EVENT_MY_APPLICATION_CHANGED:
                        wprintf(L"PEER_EVENT_MY_APPLICATION_CHANGED event signalled\n");
                        break;

                    case PEER_EVENT_MY_OBJECT_CHANGED:
                        wprintf(L"PEER_EVENT_MY_OBJECT_CHANGED event signalled\n");
                        break;

                    case PEER_EVENT_PEOPLE_NEAR_ME_CHANGED:
                        wprintf(L"PEER_EVENT_PEOPLE_NEAR_ME_CHANGED event signalled\n");
                        break;

                    case PEER_EVENT_REQUEST_STATUS_CHANGED:
                        wprintf(L"PEER_EVENT_REQUEST_STATUS_CHANGED event signalled\n");
                        break;
                }

                switch (pEventData->eventType)
                {
                    case PEER_EVENT_WATCHLIST_CHANGED:
                              DisplayWatchListChanged(&pEventData->watchListChangedData);
                              break;
                    case PEER_EVENT_ENDPOINT_PRESENCE_CHANGED:  //intentional fallthrough
                        case PEER_EVENT_MY_PRESENCE_CHANGED:
                              DisplayPresenceChanged(&pEventData->presenceChangedData);
                              break;
                    case PEER_EVENT_ENDPOINT_APPLICATION_CHANGED:  //intentional fallthrough
                    case PEER_EVENT_MY_APPLICATION_CHANGED:
                              DisplayApplicationChanged(&pEventData->applicationChangedData);
                              break;
                    case PEER_EVENT_ENDPOINT_OBJECT_CHANGED:  //intentional fallthrough
                    case PEER_EVENT_MY_OBJECT_CHANGED:
                              DisplayObjectChanged(&pEventData->objectChangedData);
                              break;
                    case PEER_EVENT_ENDPOINT_CHANGED:  //intentional fallthrough
                    case PEER_EVENT_MY_ENDPOINT_CHANGED:
                              DisplayEndpointChanged(&pEventData->endpointChangedData);
                              break;
                    case PEER_EVENT_PEOPLE_NEAR_ME_CHANGED:
                              DisplayPeopleNearMeChanged(&pEventData->peopleNearMeChangedData);
                              break;
                    case PEER_EVENT_REQUEST_STATUS_CHANGED:
                        DisplayRequestStatusChanged(&pEventData->requestStatusChangedData);
                        break;
                    default: //do nothing
                        break;
                }

                //Print a seperator line
                wprintf(L"--------------------------------\n");

                SAFE_PEER_FREE_DATA(pEventData);
            }
        }
    }
    else
    {
        wprintf(L"PeerCollabRegisterEvent failed.\nHRESULT=0x%x\n", hr);
        PrintError(hr);
    }

    hr = S_OK;

exit:

    if (hPeerEvent != NULL)
    {
        (void) PeerCollabUnregisterEvent(hPeerEvent);
        hPeerEvent = NULL;
    }

    if (hEvent[0] != NULL)
    {
        CloseHandle(hEvent[0]);
        hEvent[0] = NULL;
    }

    if (hEvent[1] != NULL)
    {
        CloseHandle(hEvent[1]);
        hEvent[1] = NULL;
    }

    return hr; 
}