void UPhilipsHueBridge::AquireUserID(bool FromFile)
{
if (FromFile&&GetUserIDFromLocalFile())
{
// Test if the User ID stored local is authorized
auto HttpRequest1 = FHttpModule::Get().CreateRequest();
{
HttpRequest1->OnProcessRequestComplete().BindUObject(this, &UPhilipsHueBridge::HandleUserIDTestRequestComplete);
HttpRequest1->SetURL(FString(TEXT("http://")) + Configuration.IpAddress + TEXT("/api/") + ConnectedUser);
HttpRequest1->SetVerb(TEXT("GET"));
HttpRequest1->ProcessRequest();
}
return;
}
auto HttpRequest = FHttpModule::Get().CreateRequest();
{
HttpRequest->OnProcessRequestComplete().BindUObject(this, &UPhilipsHueBridge::HandleUserIDRequestComplete);
HttpRequest->SetURL(FString(TEXT("http://")) + Configuration.IpAddress + TEXT("/api"));
HttpRequest->SetHeader("Content-Type", "application/json");
HttpRequest->SetVerb(TEXT("POST"));
HttpRequest->SetContentAsString(UserRequestJson());
HttpRequest->ProcessRequest();
}
}
void GPageLoadRequestManager::ProcessNewRequest()
{
LOG_LEVEL4("ProcessNewRequest()");
LOG_LEVEL4(QString("Quantity of pending requests(") + QString::number(m_qlsReqs.count()) + ").");
while( !m_qlsReqs.isEmpty() )
{
if( m_qlsReqs.first()->GetTypeOfRequest() == GAbsPageLoadRequest::eUpdateCurrentPageRequest )
{
GUpdateCurrentPageRequest* pRequest(static_cast<GUpdateCurrentPageRequest*>(m_qlsReqs.first()));
ProcessRequest(pRequest);
m_qlsReqs.removeFirst();
}
else if( m_qlsReqs.first()->GetTypeOfRequest() == GAbsPageLoadRequest::eUpdateURLCurrentPageRequest )
{
GUpdateURLCurrentPageRequest* pRequest(static_cast<GUpdateURLCurrentPageRequest*>(m_qlsReqs.first()));
ProcessRequest(pRequest);
m_qlsReqs.removeFirst();
}
else
{
break;
}
}
if( !m_qlsReqs.isEmpty() )
{
if( m_qlsReqs.first()->GetTypeOfRequest() == GAbsPageLoadRequest::eSetPreloadedPagesRequest )
{
GSetPreloadedPagesRequest* pRequest(static_cast<GSetPreloadedPagesRequest*>(m_qlsReqs.first()));
ProcessRequest(pRequest);
}
else if( m_qlsReqs.first()->GetTypeOfRequest() == GAbsPageLoadRequest::eLoadEntirePageRequest )
{
GLoadEntirePageRequest* pRequest(static_cast<GLoadEntirePageRequest*>(m_qlsReqs.first()));
ProcessRequest(pRequest);
}
else if( m_qlsReqs.first()->GetTypeOfRequest() == GAbsPageLoadRequest::eUpdatePreloadedPageRequest )
{
GUpdatePreloadedPageRequest* pRequest(static_cast<GUpdatePreloadedPageRequest*>(m_qlsReqs.first()));
ProcessRequest(pRequest);
}
else
{
throw(GException("Cannot found the request in the internal queue."));
}
}
LOG_LEVEL4(QString("Quantity of pending requests(") + QString::number(m_qlsReqs.count()) + ").");
}
UINT WINAPI ProcessConnection(LPVOID arg) {
SOCKET connectSocket = (SOCKET) arg;
HttpConnection connection;
ConnectionInit(&connection, connectSocket);
while (TRUE) {
if (!ContextInit(&connection.ctx, &connection) )
break;
#ifdef _DEBUG
showContext(&connection.ctx);
#endif
ProcessRequest(&connection.ctx);
if (strcmp("Keep-Alive", HeaderGet(&connection.ctx.reqList, "Connection"))) {
break;
}
#ifdef _DEBUG
printf("Processing done!\n");
#endif
}
ConnectionClose(&connection);
#ifdef _DEBUG
_tprintf(_T("release connection!\n"));
#endif
return 0;
}
void* WorkerThread::Entry()
{
while( true )
{
// Did we get a request to terminate?
if(TestDestroy())
break;
ThreadRequest *request = GetRequest();
if( request )
{
// Call user's implementation for processing request
ProcessRequest( request );
wxThread::Sleep(10); // Allow other threads to work as well
delete request;
request = NULL;
continue; // to avoid the sleep
}
// Sleep for 1 seconds, and then try again
wxThread::Sleep(200);
}
return NULL;
}
void FCrashUpload::PostReportComplete()
{
if (PauseState == EUploadState::PostingReportComplete)
{
// Wait for confirmation
SetCurrentState(EUploadState::WaitingToPostReportComplete);
return;
}
AssignReportIdToPostDataBuffer();
auto Request = CreateHttpRequest();
Request->SetVerb( TEXT( "POST" ) );
Request->SetURL(UrlPrefix / TEXT("UploadComplete"));
Request->SetHeader( TEXT( "Content-Type" ), TEXT( "text/plain; charset=us-ascii" ) );
Request->SetContent(PostData);
UE_LOG( CrashReportClientLog, Log, TEXT( "Sending HTTP request: %s" ), *Request->GetURL() );
if (Request->ProcessRequest())
{
SetCurrentState(EUploadState::PostingReportComplete);
}
else
{
CheckPendingReportsForFilesToUpload();
}
}
bool FCrashUpload::SendCheckReportRequest()
{
FString XMLString;
UE_LOG(CrashReportClientLog, Log, TEXT("Sending HTTP request (checking report)"));
auto Request = CreateHttpRequest();
if (State == EUploadState::CheckingReport)
{
AssignReportIdToPostDataBuffer();
Request->SetURL(UrlPrefix / TEXT("CheckReport"));
Request->SetHeader(TEXT("Content-Type"), TEXT("text/plain; charset=us-ascii"));
}
else
{
// This part is Windows-specific on the server
ErrorReport.LoadWindowsReportXmlFile( XMLString );
// Convert the XMLString into the UTF-8.
FTCHARToUTF8 Converter( (const TCHAR*)*XMLString, XMLString.Len() );
const int32 Length = Converter.Length();
PostData.Reset( Length );
PostData.AddUninitialized( Length );
CopyAssignItems( (ANSICHAR*)PostData.GetData(), Converter.Get(), Length );
Request->SetURL(UrlPrefix / TEXT("CheckReportDetail"));
Request->SetHeader(TEXT("Content-Type"), TEXT("text/plain; charset=utf-8"));
}
UE_LOG( CrashReportClientLog, Log, TEXT( "PostData Num: %i" ), PostData.Num() );
Request->SetVerb(TEXT("POST"));
Request->SetContent(PostData);
return Request->ProcessRequest();
}
nsresult sbRequestThreadQueue::PushRequest(sbRequestItem * aRequestItem)
{
TRACE_FUNCTION("RequestType=%ui", aRequestItem->mType);
NS_ENSURE_ARG_POINTER(aRequestItem);
NS_ENSURE_STATE(mLock);
nsresult rv;
{ /* scope for request lock */
nsAutoLock lock(mLock);
nsAutoMonitor monitor(mStopWaitMonitor);
// If we're aborting or shutting down don't accept any more requests
if (mAbortRequests || mStopProcessing)
{
return NS_ERROR_ABORT;
}
rv = PushRequestInternal(aRequestItem);
NS_ENSURE_SUCCESS(rv, rv);
}
NS_ASSERTION(mBatchDepth >= 0,
"Batch depth out of whack in sbBaseDevice::PushRequest");
// Only process requests if we're not in a batch
if (mBatchDepth == 0) {
rv = ProcessRequest();
NS_ENSURE_SUCCESS(rv, rv);
}
return NS_OK;
}
void GPageLoadRequestManager::ReceiveRequest(GUpdateURLCurrentPageRequest* pReq)
{
LOG_LEVEL4("ReceiveRequest(GUpdateURLCurrentPageRequest)");
QMutexLocker oLocker(&m_qmInternalMutex);
if( !m_qmSessions.contains(pReq->GetSessionId()) )
{
LOG_LEVEL1("Invalid session id. Discarding request.");
delete pReq;
return;
}
pReq->SetRequestId(GenerateRequestId());
pReq->SetNotification(false);
if( m_qlsReqs.isEmpty() )
{
ProcessRequest(pReq);
}
else
{
m_qlsReqs << pReq;
LOG_LEVEL4(QString("Quantity of pending requests(") + QString::number(m_qlsReqs.count()) + ").");
}
}
int NetPacket::ParsePacket(char *buf, int len)
{
if ((unsigned int)len < sizeof(struct header_std)) {
return -1;
}
struct header_std *head = (struct header_std *)buf;
if (ProcessHeader(head, len)) {
return -1;
}
switch (head->msg_type) {
case MESSAGE_TYPE_REQ:
ProcessRequest((struct payload_req *)(buf + sizeof(*head)),
buf + sizeof(*head) + sizeof(struct payload_req));
break;
case MESSAGE_TYPE_ACK:
ProcessAck((struct payload_ack *)(buf + sizeof(*head)),
buf + sizeof(*head) + sizeof(struct payload_ack));
break;
default:
break;
}
return len - head->msg_size;
}
void ParameterLoaderBase::StartThread()
{
DataBlockBase* data_block;
while (data_queue_.Pop(data_block))
{
if (!Multiverso::is_pipeline_)
{
Multiverso::pipeline_barrier_->Wait();
}
if (data_block->Type() != DataBlockType::BeginClock
&& data_block->Type() != DataBlockType::EndClock) // skip Clock
{
BeginIteration();
requests_.clear();
// Parse data block
ParseAndRequest(data_block);
ProcessRequest();
EndIteration();
}
if (!Multiverso::is_pipeline_)
{
Multiverso::pipeline_barrier_->Wait();
}
}
if (!Multiverso::is_pipeline_)
{
Multiverso::pipeline_barrier_->Wait();
}
}
void http::Server::ConnectionHandlerEntry( void* param )
{
Page* page = (Page*)param;
ProcessRequest( page );
PagePool.Put( page );
}
Client::Client()
: QObject(0), qout(stdout), tcpSocket(NULL), shutdownRequested(false)
{
tcpSocket = new QTcpSocket(this);
Q_ASSERT(connect(tcpSocket, SIGNAL(hostFound()), this, SLOT(OnHostFound())));
Q_ASSERT(connect(tcpSocket, SIGNAL(readyRead()), this, SLOT(ProcessRequest())));
Q_ASSERT(connect(tcpSocket, SIGNAL(error(QAbstractSocket::SocketError)),
this, SLOT(DisplayError(QAbstractSocket::SocketError))));
}
/*
* This is the function invoked by IIS during the first event
* in the request processing pipeline. Here, we implement the
* agent functionality.
* */
REQUEST_NOTIFICATION_STATUS
CAgentModule::OnBeginRequest(IN IHttpContext* pHttpContext,
IN OUT IHttpEventProvider * pProvider)
{
REQUEST_NOTIFICATION_STATUS status = RQ_NOTIFICATION_CONTINUE;
status = ProcessRequest(pHttpContext, pProvider);
return status;
}
DWORD
NetServer::Reader(int index)
{
// init random seed for this thread:
srand(timeGetTime());
while (!server_shutdown) {
sync.acquire();
NetSock* s = conn[index];
sync.release();
if (s) {
const int MAX_REQUEST = 4096;
Text request;
/***
*** NOT SURE WHY, BUT THIS DOESN'T WORK FOR SHIT
***
*** Setting the socket timeout to 2 seconds caused it
*** to wait for two seconds, read nothing, and give up
*** with a WSAETIMEDOUT error. Meanwhile, the client
*** immediately registered a failure (during the 2 sec
*** delay) and aborted the request.
***
s->set_timeout(2000);
Text msg = s->recv();
while (msg.length() > 0 && request.length() < MAX_REQUEST) {
request += msg;
msg = s->recv();
}
***/
request = s->recv();
if (request.length() > 0 && !s->is_closed()) {
Text response = ProcessRequest(request, clients[index]);
err = s->send(response);
if (err < 0) {
err = NetLayer::GetLastError();
}
}
sync.acquire();
delete conn[index];
conn[index] = 0;
sync.release();
}
else {
Sleep(5);
}
}
return 0;
}
bool CetonRTSP::GetOptions(QStringList &options)
{
if (ProcessRequest("OPTIONS"))
{
options = _responseHeaders.value("Public").split(QRegExp(",\\s*"));
return true;
}
return false;
}
void FCrashUpload::UploadNextFile()
{
UE_LOG(CrashReportClientLog, Log, TEXT("UploadNextFile: have %d pending files"), PendingFiles.Num());
// Loop to keep trying files until a send succeeds or we run out of files
while (PendingFiles.Num() != 0)
{
FString PathOfFileToUpload = PendingFiles.Pop();
// Remember if there was already a diagnostics file in the report, so we don't send it twice
if (PathOfFileToUpload.EndsWith(GDiagnosticsFilename))
{
bDiagnosticsFileSent = true;
}
if (FPlatformFileManager::Get().GetPlatformFile().FileSize(*PathOfFileToUpload) > MaxFileSizeToUpload)
{
UE_LOG(CrashReportClientLog, Warning, TEXT("Skipping large crash report file"));
continue;
}
if (!FFileHelper::LoadFileToArray(PostData, *PathOfFileToUpload))
{
UE_LOG(CrashReportClientLog, Warning, TEXT("Failed to load crash report file"));
continue;
}
UE_LOG(CrashReportClientLog, Log, TEXT("UploadNextFile: uploading %d bytes ('%s')"), PostData.Num(), *PathOfFileToUpload);
FString Filename = FPaths::GetCleanFilename(PathOfFileToUpload);
if (Filename == "diagnostics.txt")
{
// Ensure diagnostics file is capitalized for server
Filename[0] = 'D';
}
// Set up request for upload
UE_LOG(CrashReportClientLog, Log, TEXT("Sending HTTP request (posting file)"));
auto Request = CreateHttpRequest();
Request->SetVerb(TEXT("POST"));
Request->SetHeader(TEXT("Content-Type"), TEXT("application/octet-stream"));
Request->SetURL(UrlPrefix / TEXT("UploadReportFile"));
Request->SetContent(PostData);
Request->SetHeader(TEXT("DirectoryName"), *ErrorReport.GetReportDirectoryLeafName());
Request->SetHeader(TEXT("FileName"), Filename);
Request->SetHeader(TEXT("FileLength"), FString::FromInt(PostData.Num()));
if (Request->ProcessRequest())
{
return;
}
UE_LOG(CrashReportClientLog, Warning, TEXT("Failed to send file upload request"));
}
PostReportComplete();
}
static int l_MODBUS_WriteSingleRegister(lua_State *L) {
ModbusUserData* pModbusUserData = (ModbusUserData *) luaL_checkudata(L, 1, MODULE_NAME);
pModbusUserData->request.slaveId = luaL_checkint(L, 2);
pModbusUserData->request.function = MODBUS_FUNC_WRITE_SINGLE_REGISTER;
pModbusUserData->request.startingAddress = luaL_checkint(L, 3);
pModbusUserData->request.byteCount = 1;
pModbusUserData->request.value.iValue = (uint32_t) luaL_checkint(L, 4);
pModbusUserData->request.numberOfObjects = 1; // unused
return ProcessRequest(L, pModbusUserData, 0);
}
void rpc::form_process(long long formId)
{
session().load();
if (loggedIn())
{
if (p.done(formId))
{
cppcms::json::value v = cppcms::json::object();
cppcms::json::object& obj = v.object();
// Send the ID again so we can easily create the next request
obj["id"] = formId;
obj["percent"] = 100;
return_result(v);
}
else
{
// If it's not done, then save this request and process it once we
// are notified that this form is done, or if a timeout occurs
std::unique_lock<std::mutex> lock(waiters_mutex);
std::vector<ProcessRequest>::iterator i = std::find_if(
waiters.begin(), waiters.end(), RequestIdPredicate(formId));
// Only save the request if it's the first one, otherwise somebody
// could create massive amounts of requests that hang around for up
// to the timeout using up server memory
if (i == waiters.end())
{
booster::shared_ptr<cppcms::rpc::json_call> call = release_call();
waiters.push_back(ProcessRequest(formId, call));
// If the connection is closed before it's done, remove the request
call->context().async_on_peer_reset(
boost::bind(
&rpc::remove_context,
booster::intrusive_ptr<rpc>(this),
call));
}
else
{
return_error("too many connections to this form");
}
}
}
else
{
return_error("not logged in");
}
}
/* return 0 on success, non-zero on failure */
static int get_request(int sock, struct httprequest *req)
{
int fail= FALSE;
char *reqbuf = req->reqbuf;
/*** Init the httpreqest structure properly for the upcoming request ***/
memset(req, 0, sizeof(struct httprequest));
/* here's what should not be 0 from the start */
req->testno = DOCNUMBER_NOTHING; /* safe default */
req->open = TRUE; /* connection should remain open and wait for more
commands */
/*** end of httprequest init ***/
while (req->offset < REQBUFSIZ) {
int got = sread(sock, reqbuf + req->offset, REQBUFSIZ - req->offset);
if (got <= 0) {
if (got < 0) {
perror("recv");
logmsg("recv() returned error");
return DOCNUMBER_INTERNAL;
}
logmsg("Connection closed by client");
reqbuf[req->offset]=0;
/* dump the request receivied so far to the external file */
storerequest(reqbuf);
return DOCNUMBER_INTERNAL;
}
req->offset += got;
reqbuf[req->offset] = 0;
if(ProcessRequest(req))
break;
}
if (req->offset >= REQBUFSIZ) {
logmsg("Request buffer overflow, closing connection");
reqbuf[REQBUFSIZ-1]=0;
fail = TRUE;
/* dump the request to an external file anyway */
}
else
reqbuf[req->offset]=0;
/* dump the request to an external file */
storerequest(reqbuf);
return fail; /* success */
}
nsresult sbRequestThreadQueue::BatchEnd()
{
TRACE_FUNCTION("");
NS_ENSURE_STATE(mLock);
nsAutoLock lock(mLock);
NS_ASSERTION(mBatchDepth > 0,
"sbRequestThreadQueue batch depth out of balance");
if (mBatchDepth > 0 && --mBatchDepth == 0) {
++mCurrentBatchId;
ProcessRequest();
}
return NS_OK;
}
void
CThreadInPool_ForServer::x_HandleOneRequest(bool catch_all)
{
TItemHandle handle(m_Pool->GetHandle());
if (catch_all) {
try {
ProcessRequest(handle);
} catch (std::exception& e) {
handle->MarkAsForciblyCaught();
NCBI_REPORT_EXCEPTION_X(9, "Exception from thread in pool: ", e);
// throw;
} catch (...) {
handle->MarkAsForciblyCaught();
// silently propagate non-standard exceptions because they're
// likely to be CExitThreadException.
throw;
}
}
else {
ProcessRequest(handle);
}
}
bool UPhilipsHueBridge::HandleTicker(float DeltaTime)
{
auto HttpRequest = FHttpModule::Get().CreateRequest();
{
HttpRequest->OnProcessRequestComplete().BindUObject(this, &UPhilipsHueBridge::HandleHttpRequestComplete);
HttpRequest->SetURL(FString(TEXT("http://")) + Configuration.IpAddress + TEXT("/api/") + ConnectedUser + TEXT("/lights"));
HttpRequest->SetVerb(TEXT("GET"));
HttpRequest->ProcessRequest();
}
return !ConnectedUser.IsEmpty();
}
void UPhilipsHueBridge::SetLightStateByLightIDRaw(const int32 LightID, const FString StateJson)
{
if (!Connected)return;
auto HttpRequest = FHttpModule::Get().CreateRequest();
{
FString LightIDStr = FString::FromInt(LightID);
HttpRequest->OnProcessRequestComplete().BindUObject(this, &UPhilipsHueBridge::HandleLightStateRequestComplete);
HttpRequest->SetURL(FString(TEXT("http://")) + Configuration.IpAddress + TEXT("/api/") + ConnectedUser + TEXT("/lights/") + LightIDStr + TEXT("/state"));
HttpRequest->SetHeader("Content-Type", "application/json");
HttpRequest->SetVerb(TEXT("PUT"));
HttpRequest->SetContentAsString(StateJson);
HttpRequest->ProcessRequest();
}
}
void SocksConnection::HandleRequest()
{
const int bytes_left = _addr_len - _addr_buf.count();
_addr_buf.append(_socket->read(bytes_left));
qDebug() << "_addr_buf len" << _addr_buf.count();
if(_addr_buf.count() == _addr_len) {
ProcessRequest();
}
ReadFromSocket();
}
static int l_MODBUS_WriteMultipleRegisters(lua_State *L) {
size_t byteCount;
ModbusUserData* pModbusUserData = (ModbusUserData *) luaL_checkudata(L, 1, MODULE_NAME);
pModbusUserData->request.slaveId = luaL_checkint(L, 2);
pModbusUserData->request.function = MODBUS_FUNC_WRITE_MULTIPLE_REGISTERS;
pModbusUserData->request.startingAddress = luaL_checkint(L, 3);
pModbusUserData->request.value.pValues = (void*) luaL_checklstring(L, 4, &byteCount);
pModbusUserData->request.numberOfObjects = byteCount >> 1;
pModbusUserData->request.byteCount = byteCount;
return ProcessRequest(L, pModbusUserData, 0);
}
bool CetonRTSP::Describe(void)
{
if (!ProcessRequest("DESCRIBE"))
return false;
if (!_responseContent.contains("m=video 0 RTP/AVP 33"))
{
LOG(VB_RECORD, LOG_ERR, LOC + "expected content to be type "
"\"m=video 0 RTP/AVP 33\" but it appears not to be");
return false;
}
return true;
}
static int l_MODBUS_ReadDiscreteInputs(lua_State *L) {
ModbusUserData* pModbusUserData = (ModbusUserData *) luaL_checkudata(L, 1, MODULE_NAME);
pModbusUserData->request.slaveId = luaL_checkint(L, 2);
pModbusUserData->request.function = MODBUS_FUNC_READ_DISCRETE_INPUTS;
pModbusUserData->request.startingAddress = luaL_checkint(L, 3);
pModbusUserData->request.numberOfObjects = luaL_checkint(L, 4);
if (pModbusUserData->request.numberOfObjects > 0) {
pModbusUserData->request.byteCount = ((pModbusUserData->request.numberOfObjects / 8) + (((pModbusUserData->request.numberOfObjects % 8) != 0) ? 1 : 0));
pModbusUserData->allocated = malloc(pModbusUserData->request.byteCount * sizeof(uint8_t));
pModbusUserData->request.value.pValues = pModbusUserData->allocated;
}
return ProcessRequest(L, pModbusUserData, 0);
}
void CDataBaseThread::__run()
{
while ( true )
{
if ( ProcessRequest() )
break ;
if ( !m_bRunning )
{
ProcessRequest();
break;
}
Sleep(1);
if ( time(NULL) >= m_tNextMysqlPingTime )
{
unsigned long id = mysql_thread_id(m_pMySql);
mysql_ping(m_pMySql);
if ( id != mysql_thread_id(m_pMySql) )
{
// reconnected ;
if (!mysql_set_character_set(m_pMySql, "utf8"))
{
printf("Reconnect !!! New client character set: %s\n",
mysql_character_set_name(m_pMySql));
}
}
m_tNextMysqlPingTime = time(NULL) + MYSQL_PING_TIME;
}
}
if ( m_pMySql )
{
mysql_close(m_pMySql) ;
}
}
static int l_MODBUS_ReadInputRegisters(lua_State *L) {
ModbusUserData* pModbusUserData = (ModbusUserData *) luaL_checkudata(L, 1, MODULE_NAME);
pModbusUserData->request.slaveId = luaL_checkint(L, 2);
pModbusUserData->request.function = MODBUS_FUNC_READ_INPUT_REGISTERS;
pModbusUserData->request.startingAddress = luaL_checkint(L, 3);
pModbusUserData->request.numberOfObjects = luaL_checkint(L, 4);
if (pModbusUserData->request.numberOfObjects > 0) {
pModbusUserData->request.byteCount = pModbusUserData->request.numberOfObjects << 1;
pModbusUserData->allocated = malloc(pModbusUserData->request.numberOfObjects * sizeof(uint16_t));
pModbusUserData->request.value.pValues = pModbusUserData->allocated;
}
return ProcessRequest(L, pModbusUserData, 0);
}
void
nsScriptLoader::ProcessPendingRequests()
{
nsRefPtr<nsScriptLoadRequest> request;
while (mPendingRequests.Count() && ReadyToExecuteScripts() &&
!(request = mPendingRequests[0])->mLoading) {
mPendingRequests.RemoveObjectAt(0);
ProcessRequest(request);
}
while (!mPendingChildLoaders.IsEmpty() && ReadyToExecuteScripts()) {
nsRefPtr<nsScriptLoader> child = mPendingChildLoaders[0];
mPendingChildLoaders.RemoveElementAt(0);
child->RemoveExecuteBlocker();
}
}