#include "config.h"
#include "HostRecord.h"
#include "Logging.h"
#include "NetworkConnectionToWebProcess.h"
#include "NetworkProcess.h"
#include "NetworkResourceLoadParameters.h"
#include "NetworkResourceLoadScheduler.h"
#include "NetworkResourceLoader.h"
#include <wtf/MainThread.h>
#if ENABLE(NETWORK_PROCESS)
using namespace WebCore;
namespace WebKit {
HostRecord::HostRecord(const String& name, int maxRequestsInFlight)
: m_name(name)
, m_maxRequestsInFlight(maxRequestsInFlight)
{
}
HostRecord::~HostRecord()
{
#ifndef NDEBUG
ASSERT(m_loadersInProgress.isEmpty());
for (unsigned p = 0; p <= ResourceLoadPriorityHighest; p++)
ASSERT(m_loadersPending[p].isEmpty());
#endif
}
void HostRecord::scheduleResourceLoader(PassRefPtr<NetworkResourceLoader> loader)
{
ASSERT(RunLoop::isMain());
loader->setHostRecord(this);
if (loader->isSynchronous())
m_syncLoadersPending.append(loader);
else
m_loadersPending[loader->priority()].append(loader);
}
void HostRecord::addLoaderInProgress(NetworkResourceLoader* loader)
{
ASSERT(RunLoop::isMain());
m_loadersInProgress.add(loader);
loader->setHostRecord(this);
}
inline bool removeLoaderFromQueue(NetworkResourceLoader* loader, LoaderQueue& queue)
{
LoaderQueue::iterator end = queue.end();
for (LoaderQueue::iterator it = queue.begin(); it != end; ++it) {
if (it->get() == loader) {
loader->setHostRecord(0);
queue.remove(it);
return true;
}
}
return false;
}
void HostRecord::removeLoader(NetworkResourceLoader* loader)
{
ASSERT(RunLoop::isMain());
NetworkResourceLoaderSet::iterator i = m_loadersInProgress.find(loader);
if (i != m_loadersInProgress.end()) {
i->get()->setHostRecord(0);
m_loadersInProgress.remove(i);
return;
}
if (removeLoaderFromQueue(loader, m_syncLoadersPending))
return;
for (int priority = ResourceLoadPriorityHighest; priority >= ResourceLoadPriorityLowest; --priority) {
if (removeLoaderFromQueue(loader, m_loadersPending[priority]))
return;
}
}
bool HostRecord::hasRequests() const
{
if (!m_loadersInProgress.isEmpty())
return true;
for (unsigned p = 0; p <= ResourceLoadPriorityHighest; p++) {
if (!m_loadersPending[p].isEmpty())
return true;
}
return false;
}
uint64_t HostRecord::pendingRequestCount() const
{
uint64_t count = 0;
for (unsigned p = 0; p <= ResourceLoadPriorityHighest; p++)
count += m_loadersPending[p].size();
return count;
}
uint64_t HostRecord::activeLoadCount() const
{
return m_loadersInProgress.size();
}
void HostRecord::servePendingRequestsForQueue(LoaderQueue& queue, ResourceLoadPriority priority)
{
bool shouldLimitRequests = !name().isNull();
if (shouldLimitRequests && priority == ResourceLoadPriorityVeryLow && !m_loadersInProgress.isEmpty())
return;
while (!queue.isEmpty()) {
RefPtr<NetworkResourceLoader> loader = queue.first();
ASSERT(loader->hostRecord() == this);
if (!loader->connectionToWebProcess()) {
removeLoader(loader.get());
continue;
}
if (shouldLimitRequests && limitsRequests(priority, loader.get()))
return;
m_loadersInProgress.add(loader);
queue.removeFirst();
LOG(NetworkScheduling, "(NetworkProcess) HostRecord::servePendingRequestsForQueue - Starting load of %s\n", loader->request().url().string().utf8().data());
loader->start();
}
}
void HostRecord::servePendingRequests(ResourceLoadPriority minimumPriority)
{
LOG(NetworkScheduling, "(NetworkProcess) HostRecord::servePendingRequests Host name='%s'", name().utf8().data());
servePendingRequestsForQueue(m_syncLoadersPending, ResourceLoadPriorityHighest);
for (int priority = ResourceLoadPriorityHighest; priority >= minimumPriority; --priority)
servePendingRequestsForQueue(m_loadersPending[priority], (ResourceLoadPriority)priority);
}
bool HostRecord::limitsRequests(ResourceLoadPriority priority, NetworkResourceLoader* loader) const
{
ASSERT(loader);
ASSERT(loader->connectionToWebProcess());
if (priority == ResourceLoadPriorityVeryLow && !m_loadersInProgress.isEmpty())
return true;
if (loader->connectionToWebProcess()->isSerialLoadingEnabled() && m_loadersInProgress.size() >= 1)
return true;
if (m_loadersInProgress.size() == m_maxRequestsInFlight && !loader->isSynchronous())
return true;
if (m_loadersInProgress.size() > m_maxRequestsInFlight) {
#ifndef NDEBUG
NetworkResourceLoaderSet::iterator i = m_loadersInProgress.begin();
NetworkResourceLoaderSet::iterator end = m_loadersInProgress.end();
for (; i != end; ++i) {
if (i->get()->isSynchronous())
break;
}
ASSERT(i != end);
#endif
return true;
}
return false;
}
}
#endif // ENABLE(NETWORK_PROCESS)