bool
HttpChannelChild::RecvOnStartRequest(const nsHttpResponseHead& responseHead,
const PRBool& useResponseHead,
const RequestHeaderTuples& requestHeaders,
const PRBool& isFromCache,
const PRBool& cacheEntryAvailable,
const PRUint32& cacheExpirationTime,
const nsCString& cachedCharset,
const nsCString& securityInfoSerialization,
const PRNetAddr& selfAddr,
const PRNetAddr& peerAddr)
{
if (ShouldEnqueue()) {
EnqueueEvent(new StartRequestEvent(this, responseHead, useResponseHead,
requestHeaders,
isFromCache, cacheEntryAvailable,
cacheExpirationTime, cachedCharset,
securityInfoSerialization, selfAddr,
peerAddr));
} else {
OnStartRequest(responseHead, useResponseHead, requestHeaders, isFromCache,
cacheEntryAvailable, cacheExpirationTime, cachedCharset,
securityInfoSerialization, selfAddr, peerAddr);
}
return true;
}
void __thiscall
GrantControl_Execute()
{
if (SessionType.GameSession && !PlayerPtr->Defeated)
{
if (CurrentObjectsArray.ActiveCount > 0)
{
ObjectClass *first = *CurrentObjectsArray.Vector;
int32_t his_id = first->vftable->Owning_HouseID(first);
if (PlayerPtr->ID != his_id
&&
HouseClass__Is_Ally(PlayerPtr, his_id))
{
EventClass e;
EventClass__EventClass_PlayerID(&e, PlayerPtr->ID,
EVENTTYPE_GRANTCONTROL, his_id);
WWDebug_Printf("Enqueing event %s => %d, %d\n", "GRANTCONTROL",
PlayerPtr->ID, his_id);
EnqueueEvent(&e);
}
}
}
}
bool
HttpChannelChild::RecvCancelEarly(const nsresult& status)
{
if (ShouldEnqueue()) {
EnqueueEvent(new CancelEvent(this, status));
} else {
OnCancel(status);
}
return true;
}
bool
HttpChannelChild::RecvRedirect3Complete()
{
if (ShouldEnqueue()) {
EnqueueEvent(new Redirect3Event(this));
} else {
Redirect3Complete();
}
return true;
}
bool
HttpChannelChild::RecvOnStatus(const nsresult& status)
{
if (ShouldEnqueue()) {
EnqueueEvent(new StatusEvent(this, status));
} else {
OnStatus(status);
}
return true;
}
bool
FTPChannelChild::RecvOnStopRequest(const nsresult& statusCode)
{
if (ShouldEnqueue()) {
EnqueueEvent(new FTPStopRequestEvent(this, statusCode));
} else {
DoOnStopRequest(statusCode);
}
return true;
}
bool
FTPChannelChild::RecvCancelEarly(const nsresult& statusCode)
{
if (ShouldEnqueue()) {
EnqueueEvent(new FTPCancelEarlyEvent(this, statusCode));
} else {
DoCancelEarly(statusCode);
}
return true;
}
bool
FTPChannelChild::RecvDeleteSelf()
{
if (ShouldEnqueue()) {
EnqueueEvent(new FTPDeleteSelfEvent(this));
} else {
DoDeleteSelf();
}
return true;
}
bool
HttpChannelChild::RecvOnProgress(const PRUint64& progress,
const PRUint64& progressMax)
{
if (ShouldEnqueue()) {
EnqueueEvent(new ProgressEvent(this, progress, progressMax));
} else {
OnProgress(progress, progressMax);
}
return true;
}
bool
FTPChannelChild::RecvOnDataAvailable(const nsCString& data,
const PRUint32& offset,
const PRUint32& count)
{
if (ShouldEnqueue()) {
EnqueueEvent(new FTPDataAvailableEvent(this, data, offset, count));
} else {
DoOnDataAvailable(data, offset, count);
}
return true;
}
void InternalSubscription::TriggerEvent(NodeId node, Event event)
{
boost::shared_lock<boost::shared_mutex> lock(DbMutex);
MonitoredEventsMap::iterator it = MonitoredEvents.find(node);
if ( it == MonitoredEvents.end() )
{
if (Debug) std::cout << "InternalSubcsription | Subscription: " << Data.SubscriptionId << " has no subcsription for this event" << std::endl;
return;
}
lock.unlock();//Enqueue vill need to set a unique lock
EnqueueEvent(it->second, event);
}
bool
HttpChannelChild::RecvRedirect1Begin(PHttpChannelChild* newChannel,
const IPC::URI& newURI,
const PRUint32& redirectFlags,
const nsHttpResponseHead& responseHead)
{
if (ShouldEnqueue()) {
EnqueueEvent(new Redirect1Event(this, newChannel, newURI, redirectFlags,
responseHead));
} else {
Redirect1Begin(newChannel, newURI, redirectFlags, responseHead);
}
return true;
}
bool
HttpChannelChild::RecvOnTransportAndData(const nsresult& status,
const PRUint64& progress,
const PRUint64& progressMax,
const nsCString& data,
const PRUint32& offset,
const PRUint32& count)
{
if (ShouldEnqueue()) {
EnqueueEvent(new TransportAndDataEvent(this, status, progress, progressMax,
data, offset, count));
} else {
OnTransportAndData(status, progress, progressMax, data, offset, count);
}
return true;
}
bool
FTPChannelChild::RecvOnStartRequest(const PRInt32& aContentLength,
const nsCString& aContentType,
const PRTime& aLastModified,
const nsCString& aEntityID,
const IPC::URI& aURI)
{
if (ShouldEnqueue()) {
EnqueueEvent(new FTPStartRequestEvent(this, aContentLength, aContentType,
aLastModified, aEntityID, aURI));
} else {
DoOnStartRequest(aContentLength, aContentType, aLastModified,
aEntityID, aURI);
}
return true;
}
VOID
CM_WorkerFinishStopProtocol (
PVOID pvContext)
{
DWORD dwErr = NO_ERROR;
MESSAGE mMessage;
ULONG ulThreadCount = 0;
ulThreadCount = (ULONG)pvContext;
TRACE1(ENTER, "Entering WorkerFinishStopProtocol: active threads %u",
ulThreadCount);
/* NOTE: since this is called while the router is stopping, there is no */
/* need for it to use ENTER_XORPRTM_WORKER()/LEAVE_XORPRTM_WORKER() */
/* waits for all threads to stop */
while (ulThreadCount-- > 0)
WaitForSingleObject(g_ce.hActivitySemaphore, INFINITE);
/* acquire the lock and release it, just to be sure that all threads */
/* have quit their calls to LeaveSampleWorker() */
ACQUIRE_WRITE_LOCK(&(g_ce.rwlLock));
RELEASE_WRITE_LOCK(&(g_ce.rwlLock));
/* NOTE: there is no need to acquire g_ce.rwlLock for the call to */
/* CE_Cleanup since there are no threads competing for access to the */
/* fields being cleaned up. new competing threads aren't created till */
/* CE_Cleanup sets the protocol state to XORPRTM_STATUS_STOPPED, which */
/* is the last thing it does. */
CE_Cleanup(&g_ce);
/* inform router manager that we are done */
ZeroMemory(&mMessage, sizeof(MESSAGE));
if (EnqueueEvent(ROUTER_STOPPED, mMessage) == NO_ERROR)
SetEvent(g_ce.hMgrNotificationEvent);
TRACE0(LEAVE, "Leaving WorkerFinishStopProtocol");
}
void EnqueueReply_Immediate(u32 address)
{
EnqueueEvent(address);
}
void InputEventQueue::ProcessEvent(InputEvent & InputEvent)
{
EnqueueEvent(InputEvent);
}
