VisitedLinkProvider.cpp [plain text]
#include "config.h"
#include "VisitedLinkProvider.h"
#include "SharedMemory.h"
#include "VisitedLinkProviderMessages.h"
#include "VisitedLinkTable.h"
#include "VisitedLinkTableControllerMessages.h"
#include "WebProcessMessages.h"
#include "WebProcessPool.h"
#include "WebProcessProxy.h"
using namespace WebCore;
namespace WebKit {
static const int visitedLinkTableMaxLoad = 2;
static uint64_t generateIdentifier()
{
static uint64_t identifier;
return ++identifier;
}
Ref<VisitedLinkProvider> VisitedLinkProvider::create()
{
return adoptRef(*new VisitedLinkProvider);
}
VisitedLinkProvider::~VisitedLinkProvider()
{
for (WebProcessProxy* process : m_processes) {
process->removeMessageReceiver(Messages::VisitedLinkProvider::messageReceiverName(), m_identifier);
process->didDestroyVisitedLinkProvider(*this);
}
}
VisitedLinkProvider::VisitedLinkProvider()
: m_identifier(generateIdentifier())
, m_keyCount(0)
, m_tableSize(0)
, m_pendingVisitedLinksTimer(RunLoop::main(), this, &VisitedLinkProvider::pendingVisitedLinksTimerFired)
{
}
void VisitedLinkProvider::addProcess(WebProcessProxy& process)
{
ASSERT(process.state() == WebProcessProxy::State::Running);
if (!m_processes.add(&process).isNewEntry)
return;
process.addMessageReceiver(Messages::VisitedLinkProvider::messageReceiverName(), m_identifier, *this);
if (!m_keyCount)
return;
ASSERT(m_table.sharedMemory());
sendTable(process);
}
void VisitedLinkProvider::removeProcess(WebProcessProxy& process)
{
ASSERT(m_processes.contains(&process));
m_processes.remove(&process);
process.removeMessageReceiver(Messages::VisitedLinkProvider::messageReceiverName(), m_identifier);
}
void VisitedLinkProvider::addVisitedLinkHash(LinkHash linkHash)
{
m_pendingVisitedLinks.add(linkHash);
if (!m_pendingVisitedLinksTimer.isActive())
m_pendingVisitedLinksTimer.startOneShot(0);
}
void VisitedLinkProvider::removeAll()
{
m_pendingVisitedLinksTimer.stop();
m_pendingVisitedLinks.clear();
m_keyCount = 0;
m_tableSize = 0;
m_table.clear();
for (WebProcessProxy* process : m_processes) {
ASSERT(process->processPool().processes().contains(process));
process->connection()->send(Messages::VisitedLinkTableController::RemoveAllVisitedLinks(), m_identifier);
}
}
void VisitedLinkProvider::webProcessWillOpenConnection(WebProcessProxy&, IPC::Connection&)
{
}
void VisitedLinkProvider::webProcessDidCloseConnection(WebProcessProxy&, IPC::Connection&)
{
}
void VisitedLinkProvider::addVisitedLinkHashFromPage(uint64_t pageID, LinkHash linkHash)
{
if (WebPageProxy* webPageProxy = WebProcessProxy::webPage(pageID)) {
if (!webPageProxy->addsVisitedLinks())
return;
}
addVisitedLinkHash(linkHash);
}
static unsigned nextPowerOf2(unsigned v)
{
v--;
v |= v >> 1;
v |= v >> 2;
v |= v >> 4;
v |= v >> 8;
v |= v >> 16;
v++;
return v;
}
static unsigned tableSizeForKeyCount(unsigned keyCount)
{
unsigned tableSize = nextPowerOf2(keyCount * visitedLinkTableMaxLoad);
size_t minimumTableSize = SharedMemory::systemPageSize() / sizeof(LinkHash);
if (tableSize < minimumTableSize)
return minimumTableSize;
return tableSize;
}
void VisitedLinkProvider::pendingVisitedLinksTimerFired()
{
unsigned currentTableSize = m_tableSize;
unsigned newTableSize = tableSizeForKeyCount(m_keyCount + m_pendingVisitedLinks.size());
newTableSize = std::max(currentTableSize, newTableSize);
if (currentTableSize != newTableSize) {
resizeTable(newTableSize);
return;
}
Vector<WebCore::LinkHash> addedVisitedLinks;
for (auto linkHash : m_pendingVisitedLinks) {
if (m_table.addLinkHash(linkHash)) {
addedVisitedLinks.append(linkHash);
m_keyCount++;
}
}
m_pendingVisitedLinks.clear();
if (addedVisitedLinks.isEmpty())
return;
for (WebProcessProxy* process : m_processes) {
ASSERT(process->processPool().processes().contains(process));
if (addedVisitedLinks.size() > 20)
process->connection()->send(Messages::VisitedLinkTableController::AllVisitedLinkStateChanged(), m_identifier);
else
process->connection()->send(Messages::VisitedLinkTableController::VisitedLinkStateChanged(addedVisitedLinks), m_identifier);
}
}
void VisitedLinkProvider::resizeTable(unsigned newTableSize)
{
RefPtr<SharedMemory> newTableMemory = SharedMemory::allocate(newTableSize * sizeof(LinkHash));
if (!newTableMemory) {
LOG_ERROR("Could not allocate shared memory for visited link table");
return;
}
memset(newTableMemory->data(), 0, newTableMemory->size());
RefPtr<SharedMemory> currentTableMemory = m_table.sharedMemory();
unsigned currentTableSize = m_tableSize;
m_table.setSharedMemory(newTableMemory);
m_tableSize = newTableSize;
if (currentTableMemory) {
ASSERT_UNUSED(currentTableSize, currentTableMemory->size() == currentTableSize * sizeof(LinkHash));
const LinkHash* currentLinkHashes = static_cast<const LinkHash*>(currentTableMemory->data());
for (unsigned i = 0; i < currentTableSize; ++i) {
LinkHash linkHash = currentLinkHashes[i];
if (!linkHash)
continue;
bool didAddLinkHash = m_table.addLinkHash(linkHash);
ASSERT_UNUSED(didAddLinkHash, didAddLinkHash);
}
}
for (auto linkHash : m_pendingVisitedLinks) {
if (m_table.addLinkHash(linkHash))
m_keyCount++;
}
m_pendingVisitedLinks.clear();
for (WebProcessProxy* process : m_processes)
sendTable(*process);
}
void VisitedLinkProvider::sendTable(WebProcessProxy& process)
{
ASSERT(process.processPool().processes().contains(&process));
SharedMemory::Handle handle;
if (!m_table.sharedMemory()->createHandle(handle, SharedMemory::Protection::ReadOnly))
return;
process.connection()->send(Messages::VisitedLinkTableController::SetVisitedLinkTable(handle), m_identifier);
}
}