void ChildProcessProxy::abortProcessLaunchIfNeeded()
{
if (!isLaunching())
return;
m_processLauncher->invalidate();
m_processLauncher = 0;
}
void NetworkProcessProxy::getNetworkProcessConnection(PassRefPtr<Messages::WebProcessProxy::GetNetworkProcessConnection::DelayedReply> reply)
{
m_pendingConnectionReplies.append(reply);
if (isLaunching()) {
m_numPendingConnectionRequests++;
return;
}
connection()->send(Messages::NetworkProcess::CreateNetworkConnectionToWebProcess(), 0, CoreIPC::DispatchMessageEvenWhenWaitingForSyncReply);
}
// Asks the plug-in process to create a new connection to a web process. The connection identifier will be
// encoded in the given argument encoder and sent back to the connection of the given web process.
void PluginProcessProxy::getPluginProcessConnection(PassRefPtr<Messages::WebProcessProxy::GetPluginProcessConnection::DelayedReply> reply)
{
m_pendingConnectionReplies.append(reply);
if (isLaunching()) {
m_numPendingConnectionRequests++;
return;
}
// Ask the plug-in process to create a connection. Since the plug-in can be waiting for a synchronous reply
// we need to make sure that this message is always processed, even when the plug-in is waiting for a synchronus reply.
m_connection->send(Messages::PluginProcess::CreateWebProcessConnection(), 0, IPC::DispatchMessageEvenWhenWaitingForSyncReply);
}
void PluginProcessProxy::getSitesWithData(WebPluginSiteDataManager* webPluginSiteDataManager, uint64_t callbackID)
{
ASSERT(!m_pendingGetSitesReplies.contains(callbackID));
m_pendingGetSitesReplies.set(callbackID, webPluginSiteDataManager);
if (isLaunching()) {
m_pendingGetSitesRequests.append(callbackID);
return;
}
// Ask the plug-in process for the sites with data.
m_connection->send(Messages::PluginProcess::GetSitesWithData(callbackID), 0);
}
bool ChildProcessProxy::sendMessage(PassOwnPtr<CoreIPC::MessageEncoder> encoder, unsigned messageSendFlags)
{
// If we're waiting for the web process to launch, we need to stash away the messages so we can send them once we have
// a CoreIPC connection.
if (isLaunching()) {
m_pendingMessages.append(std::make_pair(encoder, messageSendFlags));
return true;
}
// If the web process has exited, connection will be null here.
if (!m_connection)
return false;
return connection()->sendMessage(encoder, messageSendFlags);
}
bool WebProcessProxy::sendMessage(CoreIPC::MessageID messageID, PassOwnPtr<CoreIPC::ArgumentEncoder> arguments, unsigned messageSendFlags)
{
// If we're waiting for the web process to launch, we need to stash away the messages so we can send them once we have
// a CoreIPC connection.
if (isLaunching()) {
m_pendingMessages.append(make_pair(CoreIPC::Connection::OutgoingMessage(messageID, arguments), messageSendFlags));
return true;
}
// If the web process has exited, m_connection will be null here.
if (!m_connection)
return false;
return connection()->sendMessage(messageID, arguments, messageSendFlags);
}
void PluginProcessProxy::clearSiteData(WebPluginSiteDataManager* webPluginSiteDataManager, const Vector<String>& sites, uint64_t flags, uint64_t maxAgeInSeconds, uint64_t callbackID)
{
ASSERT(!m_pendingClearSiteDataReplies.contains(callbackID));
m_pendingClearSiteDataReplies.set(callbackID, webPluginSiteDataManager);
if (isLaunching()) {
ClearSiteDataRequest request;
request.sites = sites;
request.flags = flags;
request.maxAgeInSeconds = maxAgeInSeconds;
request.callbackID = callbackID;
m_pendingClearSiteDataRequests.append(request);
return;
}
// Ask the plug-in process to clear the site data.
m_connection->send(Messages::PluginProcess::ClearSiteData(sites, flags, maxAgeInSeconds, callbackID), 0);
}
