WebProcessConnection.cpp [plain text]
#include "config.h"
#include "WebProcessConnection.h"
#if ENABLE(NETSCAPE_PLUGIN_API)
#include "ActivityAssertion.h"
#include "ArgumentCoders.h"
#include "NPObjectMessageReceiverMessages.h"
#include "NPRemoteObjectMap.h"
#include "PluginControllerProxy.h"
#include "PluginCreationParameters.h"
#include "PluginProcess.h"
#include "PluginProcessConnectionMessages.h"
#include "PluginProxyMessages.h"
#include "WebProcessConnectionMessages.h"
#include <unistd.h>
#include <wtf/RunLoop.h>
#include <wtf/TemporaryChange.h>
using namespace WebCore;
namespace WebKit {
static IPC::Connection* currentConnection;
RefPtr<WebProcessConnection> WebProcessConnection::create(IPC::Connection::Identifier connectionIdentifier)
{
return adoptRef(*new WebProcessConnection(connectionIdentifier));
}
WebProcessConnection::~WebProcessConnection()
{
ASSERT(m_pluginControllers.isEmpty());
ASSERT(!m_npRemoteObjectMap);
ASSERT(!m_connection);
}
WebProcessConnection::WebProcessConnection(IPC::Connection::Identifier connectionIdentifier)
{
m_connection = IPC::Connection::createServerConnection(connectionIdentifier, *this);
m_npRemoteObjectMap = NPRemoteObjectMap::create(m_connection.get());
m_connection->setOnlySendMessagesAsDispatchWhenWaitingForSyncReplyWhenProcessingSuchAMessage(true);
m_connection->open();
}
void WebProcessConnection::addPluginControllerProxy(std::unique_ptr<PluginControllerProxy> pluginController)
{
uint64_t pluginInstanceID = pluginController->pluginInstanceID();
ASSERT(!m_pluginControllers.contains(pluginInstanceID));
m_pluginControllers.set(pluginInstanceID, WTF::move(pluginController));
}
void WebProcessConnection::destroyPluginControllerProxy(PluginControllerProxy* pluginController)
{
pluginController->destroy();
}
void WebProcessConnection::removePluginControllerProxy(PluginControllerProxy* pluginController, Plugin* plugin)
{
unsigned pluginInstanceID = pluginController->pluginInstanceID();
{
ASSERT(m_pluginControllers.contains(pluginInstanceID));
std::unique_ptr<PluginControllerProxy> pluginControllerUniquePtr = m_pluginControllers.take(pluginInstanceID);
ASSERT(pluginControllerUniquePtr.get() == pluginController);
}
if (plugin)
m_npRemoteObjectMap->pluginDestroyed(plugin);
if (!m_pluginControllers.isEmpty())
return;
m_npRemoteObjectMap = nullptr;
m_connection->invalidate();
m_connection = nullptr;
PluginProcess::singleton().removeWebProcessConnection(this);
}
void WebProcessConnection::setGlobalException(const String& exceptionString)
{
if (!currentConnection)
return;
currentConnection->sendSync(Messages::PluginProcessConnection::SetException(exceptionString), Messages::PluginProcessConnection::SetException::Reply(), 0);
}
void WebProcessConnection::didReceiveMessage(IPC::Connection& connection, IPC::MessageDecoder& decoder)
{
TemporaryChange<IPC::Connection*> currentConnectionChange(currentConnection, &connection);
if (decoder.messageReceiverName() == Messages::WebProcessConnection::messageReceiverName()) {
didReceiveWebProcessConnectionMessage(connection, decoder);
return;
}
if (!decoder.destinationID()) {
ASSERT_NOT_REACHED();
return;
}
PluginControllerProxy* pluginControllerProxy = m_pluginControllers.get(decoder.destinationID());
if (!pluginControllerProxy)
return;
PluginController::PluginDestructionProtector protector(pluginControllerProxy->asPluginController());
pluginControllerProxy->didReceivePluginControllerProxyMessage(connection, decoder);
}
void WebProcessConnection::didReceiveSyncMessage(IPC::Connection& connection, IPC::MessageDecoder& decoder, std::unique_ptr<IPC::MessageEncoder>& replyEncoder)
{
TemporaryChange<IPC::Connection*> currentConnectionChange(currentConnection, &connection);
uint64_t destinationID = decoder.destinationID();
if (!destinationID) {
didReceiveSyncWebProcessConnectionMessage(connection, decoder, replyEncoder);
return;
}
if (decoder.messageReceiverName() == Messages::NPObjectMessageReceiver::messageReceiverName()) {
m_npRemoteObjectMap->didReceiveSyncMessage(connection, decoder, replyEncoder);
return;
}
PluginControllerProxy* pluginControllerProxy = m_pluginControllers.get(decoder.destinationID());
if (!pluginControllerProxy)
return;
PluginController::PluginDestructionProtector protector(pluginControllerProxy->asPluginController());
pluginControllerProxy->didReceiveSyncPluginControllerProxyMessage(connection, decoder, replyEncoder);
}
void WebProcessConnection::didClose(IPC::Connection&)
{
Vector<PluginControllerProxy*> pluginControllers;
for (auto it = m_pluginControllers.values().begin(), end = m_pluginControllers.values().end(); it != end; ++it)
pluginControllers.append(it->get());
for (size_t i = 0; i < pluginControllers.size(); ++i)
destroyPluginControllerProxy(pluginControllers[i]);
}
void WebProcessConnection::destroyPlugin(uint64_t pluginInstanceID, bool asynchronousCreationIncomplete, PassRefPtr<Messages::WebProcessConnection::DestroyPlugin::DelayedReply> reply)
{
reply->send();
ActivityAssertion activityAssertion(PluginProcess::singleton().connectionActivity());
PluginControllerProxy* pluginControllerProxy = m_pluginControllers.get(pluginInstanceID);
if (!pluginControllerProxy) {
if (asynchronousCreationIncomplete)
m_asynchronousInstanceIDsToIgnore.add(pluginInstanceID);
return;
}
destroyPluginControllerProxy(pluginControllerProxy);
}
void WebProcessConnection::didReceiveInvalidMessage(IPC::Connection&, IPC::StringReference, IPC::StringReference)
{
}
void WebProcessConnection::createPluginInternal(const PluginCreationParameters& creationParameters, bool& result, bool& wantsWheelEvents, uint32_t& remoteLayerClientID)
{
auto pluginControllerProxy = std::make_unique<PluginControllerProxy>(this, creationParameters);
PluginControllerProxy* pluginControllerProxyPtr = pluginControllerProxy.get();
addPluginControllerProxy(WTF::move(pluginControllerProxy));
result = pluginControllerProxyPtr->initialize(creationParameters);
if (!result)
return;
wantsWheelEvents = pluginControllerProxyPtr->wantsWheelEvents();
#if PLATFORM(COCOA)
remoteLayerClientID = pluginControllerProxyPtr->remoteLayerClientID();
#else
UNUSED_PARAM(remoteLayerClientID);
#endif
}
void WebProcessConnection::createPlugin(const PluginCreationParameters& creationParameters, PassRefPtr<Messages::WebProcessConnection::CreatePlugin::DelayedReply> reply)
{
ActivityAssertion activityAssertion(PluginProcess::singleton().connectionActivity());
PluginControllerProxy* pluginControllerProxy = m_pluginControllers.get(creationParameters.pluginInstanceID);
if (pluginControllerProxy) {
if (pluginControllerProxy->isInitializing()) {
pluginControllerProxy->setInitializationReply(reply);
return;
}
#if PLATFORM(COCOA)
reply->send(true, pluginControllerProxy->wantsWheelEvents(), pluginControllerProxy->remoteLayerClientID());
#else
reply->send(true, pluginControllerProxy->wantsWheelEvents(), 0);
#endif
return;
}
if (creationParameters.asynchronousCreationIncomplete)
m_asynchronousInstanceIDsToIgnore.add(creationParameters.pluginInstanceID);
bool result = false;
bool wantsWheelEvents = false;
uint32_t remoteLayerClientID = 0;
createPluginInternal(creationParameters, result, wantsWheelEvents, remoteLayerClientID);
reply->send(result, wantsWheelEvents, remoteLayerClientID);
}
void WebProcessConnection::createPluginAsynchronously(const PluginCreationParameters& creationParameters)
{
if (m_asynchronousInstanceIDsToIgnore.contains(creationParameters.pluginInstanceID)) {
m_asynchronousInstanceIDsToIgnore.remove(creationParameters.pluginInstanceID);
return;
}
bool result = false;
bool wantsWheelEvents = false;
uint32_t remoteLayerClientID = 0;
if (creationParameters.artificialPluginInitializationDelayEnabled) {
unsigned artificialPluginInitializationDelay = 5;
sleep(artificialPluginInitializationDelay);
}
m_connection->incrementDispatchMessageMarkedDispatchWhenWaitingForSyncReplyCount();
Ref<WebProcessConnection> protect(*this);
createPluginInternal(creationParameters, result, wantsWheelEvents, remoteLayerClientID);
if (!m_connection) {
return;
}
m_connection->decrementDispatchMessageMarkedDispatchWhenWaitingForSyncReplyCount();
PluginControllerProxy* pluginControllerProxy = m_pluginControllers.get(creationParameters.pluginInstanceID);
ASSERT(pluginControllerProxy);
if (RefPtr<Messages::WebProcessConnection::CreatePlugin::DelayedReply> delayedSyncReply = pluginControllerProxy->takeInitializationReply()) {
delayedSyncReply->send(result, wantsWheelEvents, remoteLayerClientID);
return;
}
if (!result) {
m_connection->sendSync(Messages::PluginProxy::DidFailToCreatePlugin(), Messages::PluginProxy::DidFailToCreatePlugin::Reply(), creationParameters.pluginInstanceID);
return;
}
m_connection->sendSync(Messages::PluginProxy::DidCreatePlugin(wantsWheelEvents, remoteLayerClientID), Messages::PluginProxy::DidCreatePlugin::Reply(), creationParameters.pluginInstanceID);
}
void WebProcessConnection::audioHardwareDidBecomeActive()
{
m_connection->send(Messages::PluginProcessConnection::AudioHardwareDidBecomeActive(), 0);
}
void WebProcessConnection::audioHardwareDidBecomeInactive()
{
m_connection->send(Messages::PluginProcessConnection::AudioHardwareDidBecomeInactive(), 0);
}
}
#endif // ENABLE(NETSCAPE_PLUGIN_API)