NetworkProcess.cpp [plain text]
#include "config.h"
#include "NetworkProcess.h"
#if ENABLE(NETWORK_PROCESS)
#include "ArgumentCoders.h"
#include "Attachment.h"
#include "AuthenticationManager.h"
#include "CustomProtocolManager.h"
#include "Logging.h"
#include "NetworkConnectionToWebProcess.h"
#include "NetworkProcessCreationParameters.h"
#include "NetworkProcessPlatformStrategies.h"
#include "NetworkProcessProxyMessages.h"
#include "NetworkResourceLoader.h"
#include "RemoteNetworkingContext.h"
#include "SessionTracker.h"
#include "StatisticsData.h"
#include "WebContextMessages.h"
#include "WebCookieManager.h"
#include <WebCore/Logging.h>
#include <WebCore/MemoryPressureHandler.h>
#include <WebCore/ResourceRequest.h>
#include <WebCore/SessionID.h>
#include <wtf/RunLoop.h>
#include <wtf/text/CString.h>
#if ENABLE(SEC_ITEM_SHIM)
#include "SecItemShim.h"
#endif
using namespace WebCore;
namespace WebKit {
NetworkProcess& NetworkProcess::shared()
{
static NeverDestroyed<NetworkProcess> networkProcess;
return networkProcess;
}
NetworkProcess::NetworkProcess()
: m_hasSetCacheModel(false)
, m_cacheModel(CacheModelDocumentViewer)
#if PLATFORM(COCOA)
, m_clearCacheDispatchGroup(0)
#endif
{
NetworkProcessPlatformStrategies::initialize();
addSupplement<AuthenticationManager>();
addSupplement<WebCookieManager>();
#if ENABLE(CUSTOM_PROTOCOLS)
addSupplement<CustomProtocolManager>();
#endif
}
NetworkProcess::~NetworkProcess()
{
}
AuthenticationManager& NetworkProcess::authenticationManager()
{
return *supplement<AuthenticationManager>();
}
DownloadManager& NetworkProcess::downloadManager()
{
static NeverDestroyed<DownloadManager> downloadManager(this);
return downloadManager;
}
void NetworkProcess::removeNetworkConnectionToWebProcess(NetworkConnectionToWebProcess* connection)
{
size_t vectorIndex = m_webProcessConnections.find(connection);
ASSERT(vectorIndex != notFound);
m_webProcessConnections.remove(vectorIndex);
}
bool NetworkProcess::shouldTerminate()
{
return false;
}
void NetworkProcess::didReceiveMessage(IPC::Connection* connection, IPC::MessageDecoder& decoder)
{
if (messageReceiverMap().dispatchMessage(connection, decoder))
return;
didReceiveNetworkProcessMessage(connection, decoder);
}
void NetworkProcess::didReceiveSyncMessage(IPC::Connection* connection, IPC::MessageDecoder& decoder, std::unique_ptr<IPC::MessageEncoder>& replyEncoder)
{
messageReceiverMap().dispatchSyncMessage(connection, decoder, replyEncoder);
}
void NetworkProcess::didClose(IPC::Connection*)
{
RunLoop::current().stop();
}
void NetworkProcess::didReceiveInvalidMessage(IPC::Connection*, IPC::StringReference, IPC::StringReference)
{
RunLoop::current().stop();
}
void NetworkProcess::didCreateDownload()
{
disableTermination();
}
void NetworkProcess::didDestroyDownload()
{
enableTermination();
}
IPC::Connection* NetworkProcess::downloadProxyConnection()
{
return parentProcessConnection();
}
AuthenticationManager& NetworkProcess::downloadsAuthenticationManager()
{
return authenticationManager();
}
void NetworkProcess::initializeNetworkProcess(const NetworkProcessCreationParameters& parameters)
{
platformInitializeNetworkProcess(parameters);
WTF::setCurrentThreadIsUserInitiated();
memoryPressureHandler().setLowMemoryHandler(lowMemoryHandler);
memoryPressureHandler().install();
setCacheModel(static_cast<uint32_t>(parameters.cacheModel));
#if PLATFORM(MAC) || USE(CFNETWORK)
SessionTracker::setIdentifierBase(parameters.uiProcessBundleIdentifier);
#endif
if (parameters.privateBrowsingEnabled)
RemoteNetworkingContext::ensurePrivateBrowsingSession(SessionID::legacyPrivateSessionID());
if (parameters.shouldUseTestingNetworkSession)
NetworkStorageSession::switchToNewTestingSession();
NetworkProcessSupplementMap::const_iterator it = m_supplements.begin();
NetworkProcessSupplementMap::const_iterator end = m_supplements.end();
for (; it != end; ++it)
it->value->initialize(parameters);
}
void NetworkProcess::initializeConnection(IPC::Connection* connection)
{
ChildProcess::initializeConnection(connection);
#if ENABLE(SEC_ITEM_SHIM)
SecItemShim::shared().initializeConnection(connection);
#endif
NetworkProcessSupplementMap::const_iterator it = m_supplements.begin();
NetworkProcessSupplementMap::const_iterator end = m_supplements.end();
for (; it != end; ++it)
it->value->initializeConnection(connection);
}
void NetworkProcess::createNetworkConnectionToWebProcess()
{
#if OS(DARWIN)
mach_port_t listeningPort;
mach_port_allocate(mach_task_self(), MACH_PORT_RIGHT_RECEIVE, &listeningPort);
RefPtr<NetworkConnectionToWebProcess> connection = NetworkConnectionToWebProcess::create(IPC::Connection::Identifier(listeningPort));
m_webProcessConnections.append(connection.release());
IPC::Attachment clientPort(listeningPort, MACH_MSG_TYPE_MAKE_SEND);
parentProcessConnection()->send(Messages::NetworkProcessProxy::DidCreateNetworkConnectionToWebProcess(clientPort), 0);
#elif USE(UNIX_DOMAIN_SOCKETS)
IPC::Connection::SocketPair socketPair = IPC::Connection::createPlatformConnection();
RefPtr<NetworkConnectionToWebProcess> connection = NetworkConnectionToWebProcess::create(socketPair.server);
m_webProcessConnections.append(connection.release());
IPC::Attachment clientSocket(socketPair.client);
parentProcessConnection()->send(Messages::NetworkProcessProxy::DidCreateNetworkConnectionToWebProcess(clientSocket), 0);
#else
notImplemented();
#endif
}
void NetworkProcess::ensurePrivateBrowsingSession(SessionID sessionID)
{
RemoteNetworkingContext::ensurePrivateBrowsingSession(sessionID);
}
void NetworkProcess::destroyPrivateBrowsingSession(SessionID sessionID)
{
SessionTracker::destroySession(sessionID);
}
void NetworkProcess::downloadRequest(uint64_t downloadID, const ResourceRequest& request)
{
downloadManager().startDownload(downloadID, request);
}
void NetworkProcess::cancelDownload(uint64_t downloadID)
{
downloadManager().cancelDownload(downloadID);
}
void NetworkProcess::setCacheModel(uint32_t cm)
{
CacheModel cacheModel = static_cast<CacheModel>(cm);
if (!m_hasSetCacheModel || cacheModel != m_cacheModel) {
m_hasSetCacheModel = true;
m_cacheModel = cacheModel;
platformSetCacheModel(cacheModel);
}
}
void NetworkProcess::getNetworkProcessStatistics(uint64_t callbackID)
{
NetworkResourceLoadScheduler& scheduler = NetworkProcess::shared().networkResourceLoadScheduler();
StatisticsData data;
data.statisticsNumbers.set("HostsPendingCount", scheduler.hostsPendingCount());
data.statisticsNumbers.set("HostsActiveCount", scheduler.hostsActiveCount());
data.statisticsNumbers.set("LoadsPendingCount", scheduler.loadsPendingCount());
data.statisticsNumbers.set("LoadsActiveCount", scheduler.loadsActiveCount());
data.statisticsNumbers.set("DownloadsActiveCount", shared().downloadManager().activeDownloadCount());
data.statisticsNumbers.set("OutstandingAuthenticationChallengesCount", shared().authenticationManager().outstandingAuthenticationChallengeCount());
parentProcessConnection()->send(Messages::WebContext::DidGetStatistics(data, callbackID), 0);
}
void NetworkProcess::terminate()
{
platformTerminate();
ChildProcess::terminate();
}
void NetworkProcess::lowMemoryHandler(bool critical)
{
platformLowMemoryHandler(critical);
WTF::releaseFastMallocFreeMemory();
}
#if !PLATFORM(COCOA)
void NetworkProcess::initializeProcess(const ChildProcessInitializationParameters&)
{
}
void NetworkProcess::initializeProcessName(const ChildProcessInitializationParameters&)
{
}
void NetworkProcess::initializeSandbox(const ChildProcessInitializationParameters&, SandboxInitializationParameters&)
{
}
void NetworkProcess::platformLowMemoryHandler(bool)
{
}
#endif
}
#endif // ENABLE(NETWORK_PROCESS)