InspectorResource::Type InspectorResource::type() const
{
if (!m_xmlHttpResponseText.isNull())
return XHR;
if (m_requestURL == m_loader->requestURL())
return Doc;
if (m_loader->frameLoader() && m_requestURL == m_loader->frameLoader()->iconURL())
return Image;
CachedResource* cachedResource = this->cachedResource();
if (!cachedResource)
return Other;
switch (cachedResource->type()) {
case CachedResource::ImageResource:
return Image;
case CachedResource::FontResource:
return Font;
case CachedResource::CSSStyleSheet:
#if ENABLE(XSLT)
case CachedResource::XSLStyleSheet:
#endif
return Stylesheet;
case CachedResource::Script:
return Script;
default:
return Other;
}
}
Type type() const
{
if (requestURL == loader->requestURL())
return Doc;
FrameLoader* frameLoader = loader->frameLoader();
if (!frameLoader)
return Other;
if (requestURL == frameLoader->iconURL())
return Image;
Document* doc = frameLoader->frame()->document();
if (!doc)
return Other;
CachedResource* cachedResource = doc->docLoader()->cachedResource(requestURL.url());
if (!cachedResource)
return Other;
switch (cachedResource->type()) {
case CachedResource::ImageResource:
return Image;
case CachedResource::CSSStyleSheet:
#if ENABLE(XSLT)
case CachedResource::XSLStyleSheet:
#endif
return Stylesheet;
case CachedResource::Script:
return Script;
default:
return Other;
}
}
void DocLoader::setAutoLoadImages(bool enable)
{
if (enable == m_autoLoadImages)
return;
m_autoLoadImages = enable;
if (!m_autoLoadImages)
return;
DocumentResourceMap::iterator end = m_documentResources.end();
for (DocumentResourceMap::iterator it = m_documentResources.begin(); it != end; ++it) {
CachedResource* resource = it->second.get();
if (resource->type() == CachedResource::ImageResource) {
CachedImage* image = const_cast<CachedImage*>(static_cast<const CachedImage*>(resource));
#ifdef ANDROID_BLOCK_NETWORK_IMAGE
if (shouldBlockNetworkImage(image->url()))
continue;
#endif
if (image->stillNeedsLoad())
cache()->loader()->load(this, image, true);
}
}
}
void CachedResourceLoader::printPreloadStats()
{
unsigned scripts = 0;
unsigned scriptMisses = 0;
unsigned stylesheets = 0;
unsigned stylesheetMisses = 0;
unsigned images = 0;
unsigned imageMisses = 0;
ListHashSet<CachedResource*>::iterator end = m_preloads.end();
for (ListHashSet<CachedResource*>::iterator it = m_preloads.begin(); it != end; ++it) {
CachedResource* res = *it;
if (res->preloadResult() == CachedResource::PreloadNotReferenced)
printf("!! UNREFERENCED PRELOAD %s\n", res->url().latin1().data());
else if (res->preloadResult() == CachedResource::PreloadReferencedWhileComplete)
printf("HIT COMPLETE PRELOAD %s\n", res->url().latin1().data());
else if (res->preloadResult() == CachedResource::PreloadReferencedWhileLoading)
printf("HIT LOADING PRELOAD %s\n", res->url().latin1().data());
if (res->type() == CachedResource::Script) {
scripts++;
if (res->preloadResult() < CachedResource::PreloadReferencedWhileLoading)
scriptMisses++;
} else if (res->type() == CachedResource::CSSStyleSheet) {
stylesheets++;
if (res->preloadResult() < CachedResource::PreloadReferencedWhileLoading)
stylesheetMisses++;
} else {
images++;
if (res->preloadResult() < CachedResource::PreloadReferencedWhileLoading)
imageMisses++;
}
if (res->errorOccurred())
memoryCache()->remove(res);
res->decreasePreloadCount();
}
m_preloads.clear();
if (scripts)
printf("SCRIPTS: %d (%d hits, hit rate %d%%)\n", scripts, scripts - scriptMisses, (scripts - scriptMisses) * 100 / scripts);
if (stylesheets)
printf("STYLESHEETS: %d (%d hits, hit rate %d%%)\n", stylesheets, stylesheets - stylesheetMisses, (stylesheets - stylesheetMisses) * 100 / stylesheets);
if (images)
printf("IMAGES: %d (%d hits, hit rate %d%%)\n", images, images - imageMisses, (images - imageMisses) * 100 / images);
}
void CachedResourceLoader::reloadImagesIfNotDeferred()
{
DocumentResourceMap::iterator end = m_documentResources.end();
for (DocumentResourceMap::iterator it = m_documentResources.begin(); it != end; ++it) {
CachedResource* resource = it->value.get();
if (resource->type() == CachedResource::ImageResource && resource->stillNeedsLoad() && !clientDefersImage(resource->url()))
const_cast<CachedResource*>(resource)->load(this, defaultCachedResourceOptions());
}
}
void CachedImage::setBodyDataFrom(const CachedResource& resource)
{
ASSERT(resource.type() == type());
const CachedImage& image = static_cast<const CachedImage&>(resource);
CachedResource::setBodyDataFrom(resource);
m_image = image.m_image;
if (m_image && is<SVGImage>(*m_image))
m_svgImageCache = std::make_unique<SVGImageCache>(&downcast<SVGImage>(*m_image));
}
SubresourceLoader::SubresourceLoader(Frame& frame, CachedResource& resource, const ResourceLoaderOptions& options)
: ResourceLoader(frame, options)
, m_resource(&resource)
, m_loadingMultipartContent(false)
, m_state(Uninitialized)
, m_requestCountTracker(InPlace, frame.document()->cachedResourceLoader(), resource)
{
#ifndef NDEBUG
subresourceLoaderCounter.increment();
#endif
#if ENABLE(CONTENT_EXTENSIONS)
m_resourceType = toResourceType(resource.type());
#endif
}
void CachedResource::loadFrom(const CachedResource& resource)
{
ASSERT(url() == resource.url());
ASSERT(type() == resource.type());
ASSERT(resource.status() == Status::Cached);
if (isCrossOrigin() && m_options.mode == FetchOptions::Mode::Cors) {
ASSERT(m_origin);
String errorMessage;
if (!WebCore::passesAccessControlCheck(resource.response(), m_options.allowCredentials, *m_origin, errorMessage)) {
setResourceError(ResourceError(String(), 0, url(), errorMessage, ResourceError::Type::AccessControl));
return;
}
}
setBodyDataFrom(resource);
setStatus(Status::Cached);
setLoading(false);
}
static String cachedResourceTypeString(const CachedResource& cachedResource)
{
switch (cachedResource.type()) {
case CachedResource::ImageResource:
return "Image";
case CachedResource::FontResource:
return "Font";
case CachedResource::CSSStyleSheet:
// Fall through.
#if ENABLE(XSLT)
case CachedResource::XSLStyleSheet:
#endif
return "Stylesheet";
case CachedResource::Script:
return "Script";
default:
break;
}
return "Other";
}
static String cachedResourceTypeString(const CachedResource& cachedResource)
{
switch (cachedResource.type()) {
case CachedResource::ImageResource:
return ResourceType::image;
case CachedResource::FontResource:
return ResourceType::font;
case CachedResource::CSSStyleSheet:
// Fall through.
#if ENABLE(XSLT)
case CachedResource::XSLStyleSheet:
#endif
return ResourceType::stylesheet;
case CachedResource::Script:
return ResourceType::script;
default:
break;
}
return ResourceType::other;
}
InspectorPageAgent::ResourceType InspectorPageAgent::cachedResourceType(const CachedResource& cachedResource)
{
switch (cachedResource.type()) {
case CachedResource::ImageResource:
return InspectorPageAgent::ImageResource;
case CachedResource::FontResource:
return InspectorPageAgent::FontResource;
case CachedResource::CSSStyleSheet:
// Fall through.
#if ENABLE(XSLT)
case CachedResource::XSLStyleSheet:
#endif
return InspectorPageAgent::StylesheetResource;
case CachedResource::Script:
return InspectorPageAgent::ScriptResource;
default:
break;
}
return InspectorPageAgent::OtherResource;
}
void DocLoader::setBlockNetworkImage(bool block)
{
if (block == m_blockNetworkImage)
return;
m_blockNetworkImage = block;
if (!m_autoLoadImages || m_blockNetworkImage)
return;
DocumentResourceMap::iterator end = m_documentResources.end();
for (DocumentResourceMap::iterator it = m_documentResources.begin(); it != end; ++it) {
CachedResource* resource = it->second.get();
if (resource->type() == CachedResource::ImageResource) {
CachedImage* image = const_cast<CachedImage*>(static_cast<const CachedImage*>(resource));
if (image->stillNeedsLoad())
cache()->loader()->load(this, image, true);
}
}
}
void CachedResourceLoader::setAutoLoadImages(bool enable)
{
if (enable == m_autoLoadImages)
return;
m_autoLoadImages = enable;
if (!m_autoLoadImages)
return;
DocumentResourceMap::iterator end = m_documentResources.end();
for (DocumentResourceMap::iterator it = m_documentResources.begin(); it != end; ++it) {
CachedResource* resource = it->second.get();
if (resource->type() == CachedResource::ImageResource) {
CachedImage* image = const_cast<CachedImage*>(static_cast<const CachedImage*>(resource));
if (image->stillNeedsLoad())
image->load(this, defaultCachedResourceOptions());
}
}
}
void DocLoader::setAutoLoadImages(bool enable)
{
if (enable == m_autoLoadImages)
return;
m_autoLoadImages = enable;
if (!m_autoLoadImages)
return;
SubCache::ResourceMap resources = m_documentResources.allResources();
SubCache::ResourceMap::iterator end = resources.end();
for(SubCache::ResourceMap::iterator it = resources.begin(); it != end; ++it) {
CachedResource* resource = it->second.get();
if (resource->type() == CachedResource::ImageResource) {
CachedImage* image = const_cast<CachedImage*>(static_cast<const CachedImage*>(resource));
if (image->stillNeedsLoad())
cache()->loader()->load(this, image, true);
}
}
}
MemoryCache::Statistics MemoryCache::getStatistics()
{
Statistics stats;
CachedResourceMap::iterator e = m_resources.end();
for (CachedResourceMap::iterator i = m_resources.begin(); i != e; ++i) {
#if ENABLE(CACHE_PARTITIONING)
for (CachedResourceItem::iterator itemIterator = i->value->begin(); itemIterator != i->value->end(); ++itemIterator) {
CachedResource* resource = itemIterator->value;
#else
CachedResource* resource = i->value;
#endif
switch (resource->type()) {
case CachedResource::ImageResource:
stats.images.addResource(resource);
break;
case CachedResource::CSSStyleSheet:
stats.cssStyleSheets.addResource(resource);
break;
case CachedResource::Script:
stats.scripts.addResource(resource);
break;
#if ENABLE(XSLT)
case CachedResource::XSLStyleSheet:
stats.xslStyleSheets.addResource(resource);
break;
#endif
case CachedResource::FontResource:
stats.fonts.addResource(resource);
break;
default:
break;
}
#if ENABLE(CACHE_PARTITIONING)
}
#endif
}
return stats;
}
PassRefPtr<ArchiveResource> DocumentLoader::subresource(const KURL& url) const
{
if (!isCommitted())
return 0;
CachedResource* resource = m_cachedResourceLoader->cachedResource(url);
if (!resource || !resource->isLoaded())
return archiveResourceForURL(url);
if (resource->type() == CachedResource::MainResource)
return 0;
// FIXME: This has the side effect of making the resource non-purgeable.
// It would be better if it didn't have this permanent effect.
if (!resource->makePurgeable(false))
return 0;
ResourceBuffer* data = resource->resourceBuffer();
if (!data)
return 0;
return ArchiveResource::create(data->sharedBuffer(), url, resource->response());
}
void CachedResourceLoader::setBlockNetworkImage(bool block)
{
if (block == m_blockNetworkImage)
return;
m_blockNetworkImage = block;
if (!m_autoLoadImages || m_blockNetworkImage)
return;
DocumentResourceMap::iterator end = m_documentResources.end();
for (DocumentResourceMap::iterator it = m_documentResources.begin(); it != end; ++it) {
CachedResource* resource = it->second.get();
if (resource->type() == CachedResource::ImageResource) {
CachedImage* image = const_cast<CachedImage*>(static_cast<const CachedImage*>(resource));
image->setAutoLoadWasPreventedBySettings(false);
if (image->stillNeedsLoad()) {
image->setLoading(true);
load(image, true);
}
}
}
}
InspectorResource::Type InspectorResource::cachedResourceType() const
{
CachedResource* cachedResource = this->cachedResource();
if (!cachedResource)
return Other;
switch (cachedResource->type()) {
case CachedResource::ImageResource:
return Image;
case CachedResource::FontResource:
return Font;
case CachedResource::CSSStyleSheet:
#if ENABLE(XSLT)
case CachedResource::XSLStyleSheet:
#endif
return Stylesheet;
case CachedResource::Script:
return Script;
default:
return Other;
}
}
void DocLoader::setAutoLoadImages(bool enable)
{
if (enable == m_autoLoadImages)
return;
m_autoLoadImages = enable;
if (!m_autoLoadImages)
return;
HashMap<String, CachedResource*>::iterator end = m_docResources.end();
for (HashMap<String, CachedResource*>::iterator it = m_docResources.begin(); it != end; ++it) {
CachedResource* resource = it->second;
if (resource->type() == CachedResource::ImageResource) {
CachedImage* image = const_cast<CachedImage*>(static_cast<const CachedImage *>(resource));
CachedResource::Status status = image->status();
if (status != CachedResource::Unknown)
continue;
cache()->loader()->load(this, image, true);
}
}
}
