void ImageDocumentParser::finish()
{
if (!isStopped() && document()->imageElement() && document()->cachedImage()) {
ImageResource* cachedImage = document()->cachedImage();
DocumentLoader* loader = document()->loader();
cachedImage->setResponse(loader->response());
cachedImage->setLoadFinishTime(loader->timing().responseEnd());
cachedImage->finish();
// Report the natural image size in the page title, regardless of zoom level.
// At a zoom level of 1 the image is guaranteed to have an integer size.
IntSize size = flooredIntSize(cachedImage->imageSize(LayoutObject::shouldRespectImageOrientation(document()->imageElement()->layoutObject()), 1.0f));
if (size.width()) {
// Compute the title, we use the decoded filename of the resource, falling
// back on the (decoded) hostname if there is no path.
String fileName = decodeURLEscapeSequences(document()->url().lastPathComponent());
if (fileName.isEmpty())
fileName = document()->url().host();
document()->setTitle(imageTitle(fileName, size));
}
document()->imageUpdated();
}
// TODO(esprehn): These null checks on Document don't make sense, document()
// will ASSERT if it was null. Do these want to check isDetached() ?
if (document())
document()->finishedParsing();
}
DocumentLoadTiming* PerformanceTiming::documentLoadTiming() const {
DocumentLoader* loader = documentLoader();
if (!loader)
return nullptr;
return &loader->timing();
}
ResourceLoadTiming* PerformanceTiming::resourceLoadTiming() const {
DocumentLoader* loader = documentLoader();
if (!loader)
return nullptr;
return loader->response().resourceLoadTiming();
}
void PluginDocumentParser::createDocumentStructure()
{
RefPtr<Element> rootElement = document()->createElement(htmlTag, false);
document()->appendChild(rootElement, IGNORE_EXCEPTION);
static_cast<HTMLHtmlElement*>(rootElement.get())->insertedByParser();
if (document()->frame() && document()->frame()->loader())
document()->frame()->loader()->dispatchDocumentElementAvailable();
RefPtr<Element> body = document()->createElement(bodyTag, false);
body->setAttribute(marginwidthAttr, "0");
body->setAttribute(marginheightAttr, "0");
body->setAttribute(styleAttr, "background-color: rgb(38,38,38)");
rootElement->appendChild(body, IGNORE_EXCEPTION);
RefPtr<Element> embedElement = document()->createElement(embedTag, false);
m_embedElement = static_cast<HTMLEmbedElement*>(embedElement.get());
m_embedElement->setAttribute(widthAttr, "100%");
m_embedElement->setAttribute(heightAttr, "100%");
m_embedElement->setAttribute(nameAttr, "plugin");
m_embedElement->setAttribute(srcAttr, document()->url().string());
DocumentLoader* loader = document()->loader();
ASSERT(loader);
if (loader)
m_embedElement->setAttribute(typeAttr, loader->writer()->mimeType());
static_cast<PluginDocument*>(document())->setPluginNode(m_embedElement);
body->appendChild(embedElement, IGNORE_EXCEPTION);
}
void MediaDocument::replaceMediaElementTimerFired(Timer<MediaDocument>&)
{
HTMLElement* htmlBody = body();
if (!htmlBody)
return;
// Set body margin width and height to 0 as that is what a PluginDocument uses.
htmlBody->setAttribute(marginwidthAttr, "0");
htmlBody->setAttribute(marginheightAttr, "0");
if (HTMLVideoElement* videoElement = descendentVideoElement(*htmlBody)) {
RefPtr<Element> element = Document::createElement(embedTag, false);
HTMLEmbedElement* embedElement = toHTMLEmbedElement(element.get());
embedElement->setAttribute(widthAttr, "100%");
embedElement->setAttribute(heightAttr, "100%");
embedElement->setAttribute(nameAttr, "plugin");
embedElement->setAttribute(srcAttr, url().string());
DocumentLoader* documentLoader = loader();
ASSERT(documentLoader);
if (documentLoader)
embedElement->setAttribute(typeAttr, documentLoader->writer().mimeType());
videoElement->parentNode()->replaceChild(embedElement, videoElement, IGNORE_EXCEPTION);
}
}
CachePolicy FrameFetchContext::cachePolicy(Document* document) const
{
if (document && document->loadEventFinished())
return CachePolicyVerify;
FrameLoadType loadType = m_frame->loader().loadType();
if (loadType == FrameLoadTypeReloadFromOrigin)
return CachePolicyReload;
Frame* parentFrame = m_frame->tree().parent();
if (parentFrame && parentFrame->isLocalFrame()) {
CachePolicy parentCachePolicy = toLocalFrame(parentFrame)->loader().fetchContext().cachePolicy(toLocalFrame(parentFrame)->document());
if (parentCachePolicy != CachePolicyVerify)
return parentCachePolicy;
}
if (loadType == FrameLoadTypeReload)
return CachePolicyRevalidate;
DocumentLoader* loader = document ? document->loader() : 0;
if (loader && loader->request().cachePolicy() == ReturnCacheDataElseLoad)
return CachePolicyHistoryBuffer;
return CachePolicyVerify;
}
PassRefPtr<SharedBuffer> InspectorResourceAgent::resourceData(Frame* frame, const KURL& url, String* textEncodingName)
{
FrameLoader* frameLoader = frame->loader();
DocumentLoader* loader = frameLoader->documentLoader();
if (equalIgnoringFragmentIdentifier(url, loader->url())) {
*textEncodingName = frame->document()->inputEncoding();
return frameLoader->documentLoader()->mainResourceData();
}
CachedResource* cachedResource = InspectorResourceAgent::cachedResource(frame, url);
if (!cachedResource)
return 0;
// Zero-sized resources don't have data at all -- so fake the empty buffer, insted of indicating error by returning 0.
if (!cachedResource->encodedSize())
return SharedBuffer::create();
if (cachedResource->isPurgeable()) {
// If the resource is purgeable then make it unpurgeable to get
// get its data. This might fail, in which case we return an
// empty String.
// FIXME: should we do something else in the case of a purged
// resource that informs the user why there is no data in the
// inspector?
if (!cachedResource->makePurgeable(false))
return 0;
}
*textEncodingName = cachedResource->encoding();
return cachedResource->data();
}
void WebFrameLoaderClient::updateGlobalHistory()
{
WebHistory* history = WebHistory::sharedHistory();
if (!history)
return;
DocumentLoader* loader = core(m_webFrame)->loader()->documentLoader();
history->addItem(loader->urlForHistory(), loader->title(), loader->urlForHistoryReflectsFailure());
}
void WebFrameLoaderClient::updateGlobalHistory()
{
WebHistory* history = WebHistory::sharedHistory();
if (!history)
return;
DocumentLoader* loader = core(m_webFrame)->loader()->documentLoader();
history->visitedURL(loader->urlForHistory(), loader->title(), loader->originalRequestCopy().httpMethod(), loader->urlForHistoryReflectsFailure(), !loader->clientRedirectSourceForHistory());
}
void InspectorApplicationCacheAgent::getManifestForFrame(ErrorString* errorString, const String& frameId, String* manifestURL)
{
DocumentLoader* documentLoader = assertFrameWithDocumentLoader(errorString, frameId);
if (!documentLoader)
return;
ApplicationCacheHost::CacheInfo info = documentLoader->applicationCacheHost()->applicationCacheInfo();
*manifestURL = info.m_manifest.string();
}
PassRefPtr<LegacyWebArchive> LegacyWebArchive::create(const String& markupString, Frame* frame, Vector<Node*>& nodes)
{
ASSERT(frame);
const ResourceResponse& response = frame->loader()->documentLoader()->response();
KURL responseURL = response.url();
// it's possible to have a response without a URL here
// <rdar://problem/5454935>
if (responseURL.isNull())
responseURL = KURL("");
PassRefPtr<ArchiveResource> mainResource = ArchiveResource::create(utf8Buffer(markupString), responseURL, response.mimeType(), "UTF-8", frame->tree()->name());
Vector<PassRefPtr<LegacyWebArchive> > subframeArchives;
Vector<PassRefPtr<ArchiveResource> > subresources;
HashSet<String> uniqueSubresources;
Vector<Node*>::iterator it = nodes.begin();
Vector<Node*>::iterator end = nodes.end();
for (; it != end; ++it) {
Frame* childFrame;
if (((*it)->hasTagName(HTMLNames::frameTag) || (*it)->hasTagName(HTMLNames::iframeTag) || (*it)->hasTagName(HTMLNames::objectTag)) &&
(childFrame = static_cast<HTMLFrameOwnerElement*>(*it)->contentFrame())) {
RefPtr<LegacyWebArchive> subframeArchive;
if (Document* document = childFrame->document())
subframeArchive = LegacyWebArchive::create(document);
else
subframeArchive = create(childFrame);
if (subframeArchive)
subframeArchives.append(subframeArchive);
else
LOG_ERROR("Unabled to archive subframe %s", childFrame->tree()->name().string().utf8().data());
} else {
Vector<KURL> subresourceURLs;
(*it)->getSubresourceURLs(subresourceURLs);
DocumentLoader* documentLoader = frame->loader()->documentLoader();
for (unsigned i = 0; i < subresourceURLs.size(); ++i) {
if (uniqueSubresources.contains(subresourceURLs[i].string()))
continue;
uniqueSubresources.add(subresourceURLs[i].string());
RefPtr<ArchiveResource> resource = documentLoader->subresource(subresourceURLs[i]);
if (resource)
subresources.append(resource.release());
else
// FIXME: should do something better than spew to console here
LOG_ERROR("Failed to archive subresource for %s", subresourceURLs[i].string().utf8().data());
}
}
}
return create(mainResource, subresources, subframeArchives);
}
bool PageCache::canCachePageContainingThisFrame(Frame& frame)
{
for (Frame* child = frame.tree().firstChild(); child; child = child->tree().nextSibling()) {
if (!canCachePageContainingThisFrame(*child))
return false;
}
FrameLoader& frameLoader = frame.loader();
DocumentLoader* documentLoader = frameLoader.documentLoader();
Document* document = frame.document();
return documentLoader
&& (documentLoader->mainDocumentError().isNull() || (documentLoader->mainDocumentError().isCancellation() && documentLoader->subresourceLoadersArePageCacheAcceptable()))
// Do not cache error pages (these can be recognized as pages with substitute data or unreachable URLs).
&& !(documentLoader->substituteData().isValid() && !documentLoader->substituteData().failingURL().isEmpty())
&& (!frameLoader.subframeLoader().containsPlugins() || frame.page()->settings().pageCacheSupportsPlugins())
&& !(frame.isMainFrame() && document->url().protocolIs("https") && documentLoader->response().cacheControlContainsNoStore())
&& frameLoader.history().currentItem()
&& !frameLoader.quickRedirectComing()
&& !documentLoader->isLoading()
&& !documentLoader->isStopping()
&& document->canSuspendActiveDOMObjectsForPageCache()
// FIXME: We should investigating caching frames that have an associated
// application cache. <rdar://problem/5917899> tracks that work.
&& documentLoader->applicationCacheHost()->canCacheInPageCache()
&& frameLoader.client().canCachePage();
}
CertificateInfo WebFrame::certificateInfo() const
{
if (!m_coreFrame)
return { };
DocumentLoader* documentLoader = m_coreFrame->loader().documentLoader();
if (!documentLoader)
return { };
return documentLoader->response().certificateInfo().valueOrCompute([] { return CertificateInfo(); });
}
void PluginView::cancelManualStreamLoad()
{
if (!frame())
return;
DocumentLoader* documentLoader = frame()->loader()->activeDocumentLoader();
ASSERT(documentLoader);
if (documentLoader->isLoadingMainResource())
documentLoader->cancelMainResourceLoad(frame()->loader()->cancelledError(m_parameters.url));
}
unsigned long long PerformanceTiming::responseStart() const
{
DocumentLoader* loader = documentLoader();
if (!loader)
return requestStart();
const ResourceLoadTiming& timing = loader->response().resourceLoadTiming();
ASSERT(timing.responseStart >= 0);
return resourceLoadTimeRelativeToAbsolute(timing.responseStart);
}
static bool contentExtensionsEnabled(const DocumentLoader& documentLoader)
{
if (auto frame = documentLoader.frame()) {
if (frame->isMainFrame())
return documentLoader.userContentExtensionsEnabled();
if (auto mainDocumentLoader = frame->mainFrame().loader().documentLoader())
return mainDocumentLoader->userContentExtensionsEnabled();
}
return true;
}
WebCore::CertificateInfo WebFrame::certificateInfo() const
{
if (!m_coreFrame)
return CertificateInfo();
DocumentLoader* documentLoader = m_coreFrame->loader().documentLoader();
if (!documentLoader)
return CertificateInfo();
return documentLoader->response().certificateInfo();
}
void PluginDocument::cancelManualPluginLoad()
{
// PluginDocument::cancelManualPluginLoad should only be called once, but there are issues
// with how many times we call beforeload on object elements. <rdar://problem/8441094>.
if (!shouldLoadPluginManually())
return;
DocumentLoader* documentLoader = frame()->loader().activeDocumentLoader();
documentLoader->cancelMainResourceLoad(frame()->loader().cancelledError(documentLoader->request()));
setShouldLoadPluginManually(false);
}
String WebFrame::url() const
{
if (!m_coreFrame)
return String();
DocumentLoader* documentLoader = m_coreFrame->loader().documentLoader();
if (!documentLoader)
return String();
return documentLoader->url().string();
}
String WebFrame::provisionalURL() const
{
if (!m_coreFrame)
return String();
DocumentLoader* provisionalDocumentLoader = m_coreFrame->loader().provisionalDocumentLoader();
if (!provisionalDocumentLoader)
return String();
return provisionalDocumentLoader->url().string();
}
void InspectorApplicationCacheAgent::getApplicationCaches(RefPtr<InspectorValue>* applicationCaches)
{
DocumentLoader* documentLoader = m_inspectorController->inspectedPage()->mainFrame()->loader()->documentLoader();
if (documentLoader) {
ApplicationCacheHost* host = documentLoader->applicationCacheHost();
ApplicationCacheHost::CacheInfo info = host->applicationCacheInfo();
ApplicationCacheHost::ResourceInfoList resources;
host->fillResourceList(&resources);
*applicationCaches = buildObjectForApplicationCache(resources, info);
}
}
void InspectorApplicationCacheAgent::getApplicationCaches(ErrorString*, RefPtr<InspectorObject>* applicationCaches)
{
DocumentLoader* documentLoader = m_inspectedPage->mainFrame()->loader()->documentLoader();
if (!documentLoader)
return;
ApplicationCacheHost* host = documentLoader->applicationCacheHost();
ApplicationCacheHost::CacheInfo info = host->applicationCacheInfo();
ApplicationCacheHost::ResourceInfoList resources;
host->fillResourceList(&resources);
*applicationCaches = buildObjectForApplicationCache(resources, info);
}
void ContentExtensionsBackend::processContentExtensionRulesForLoad(ResourceRequest& request, ResourceType resourceType, DocumentLoader& initiatingDocumentLoader)
{
Document* currentDocument = nullptr;
URL mainDocumentURL;
if (initiatingDocumentLoader.frame()) {
currentDocument = initiatingDocumentLoader.frame()->document();
if (Document* mainDocument = initiatingDocumentLoader.frame()->mainFrame().document())
mainDocumentURL = mainDocument->url();
}
ResourceLoadInfo resourceLoadInfo = { request.url(), mainDocumentURL, resourceType };
Vector<ContentExtensions::Action> actions = actionsForResourceLoad(resourceLoadInfo);
StringBuilder css;
bool willBlockLoad = false;
for (const auto& action : actions) {
switch (action.type()) {
case ContentExtensions::ActionType::BlockLoad:
willBlockLoad = true;
break;
case ContentExtensions::ActionType::BlockCookies:
request.setAllowCookies(false);
break;
case ContentExtensions::ActionType::CSSDisplayNoneSelector:
if (resourceType == ResourceType::Document)
initiatingDocumentLoader.addPendingContentExtensionDisplayNoneSelector(action.extensionIdentifier(), action.stringArgument(), action.actionID());
else if (currentDocument)
currentDocument->styleSheetCollection().addDisplayNoneSelector(action.extensionIdentifier(), action.stringArgument(), action.actionID());
break;
case ContentExtensions::ActionType::CSSDisplayNoneStyleSheet: {
StyleSheetContents* styleSheetContents = globalDisplayNoneStyleSheet(action.stringArgument());
if (styleSheetContents) {
if (resourceType == ResourceType::Document)
initiatingDocumentLoader.addPendingContentExtensionSheet(action.stringArgument(), *styleSheetContents);
else if (currentDocument)
currentDocument->styleSheetCollection().maybeAddContentExtensionSheet(action.stringArgument(), *styleSheetContents);
}
break;
}
case ContentExtensions::ActionType::IgnorePreviousRules:
case ContentExtensions::ActionType::InvalidAction:
RELEASE_ASSERT_NOT_REACHED();
}
}
if (willBlockLoad) {
if (currentDocument)
currentDocument->addConsoleMessage(MessageSource::ContentBlocker, MessageLevel::Info, makeString("Content blocker prevented frame displaying ", mainDocumentURL.string(), " from loading a resource from ", request.url().string()));
request = ResourceRequest();
}
}
static PassRefPtr<InspectorObject> buildObjectForFrameResource(Frame* frame)
{
FrameLoader* frameLoader = frame->loader();
DocumentLoader* loader = frameLoader->documentLoader();
RefPtr<InspectorObject> resourceObject = InspectorObject::create();
resourceObject->setString("url", loader->url().string());
resourceObject->setObject("loader", buildObjectForDocumentLoader(loader));
resourceObject->setObject("request", buildObjectForResourceRequest(loader->request()));
resourceObject->setObject("response", buildObjectForResourceResponse(loader->response()));
return resourceObject;
}
void InspectorNetworkAgent::didLoadResourceFromMemoryCache(DocumentLoader& loader, CachedResource& resource)
{
String loaderId = m_pageAgent->loaderId(&loader);
String frameId = m_pageAgent->frameId(loader.frame());
unsigned long identifier = loader.frame()->page()->progress().createUniqueIdentifier();
String requestId = IdentifiersFactory::requestId(identifier);
m_resourcesData->resourceCreated(requestId, loaderId);
m_resourcesData->addCachedResource(requestId, &resource);
RefPtr<Inspector::Protocol::Network::Initiator> initiatorObject = buildInitiatorObject(loader.frame() ? loader.frame()->document() : nullptr);
m_frontendDispatcher->requestServedFromMemoryCache(requestId, frameId, loaderId, loader.url().string(), timestamp(), initiatorObject, buildObjectForCachedResource(&resource, &loader));
}
Response InspectorApplicationCacheAgent::getManifestForFrame(
const String& frameId,
String* manifestURL) {
DocumentLoader* documentLoader = nullptr;
Response response = assertFrameWithDocumentLoader(frameId, documentLoader);
if (!response.isSuccess())
return response;
ApplicationCacheHost::CacheInfo info =
documentLoader->applicationCacheHost()->applicationCacheInfo();
*manifestURL = info.m_manifest.getString();
return Response::OK();
}
void InspectorApplicationCacheAgent::updateApplicationCacheStatus(LocalFrame* frame)
{
DocumentLoader* documentLoader = frame->loader().documentLoader();
if (!documentLoader)
return;
ApplicationCacheHost* host = documentLoader->applicationCacheHost();
ApplicationCacheHost::Status status = host->status();
ApplicationCacheHost::CacheInfo info = host->applicationCacheInfo();
String manifestURL = info.m_manifest.string();
m_frontend->applicationCacheStatusUpdated(m_pageAgent->frameId(frame), manifestURL, static_cast<int>(status));
}
unsigned long long PerformanceTiming::secureConnectionStart() const
{
DocumentLoader* loader = documentLoader();
if (!loader)
return 0;
const ResourceLoadTiming& timing = loader->response().resourceLoadTiming();
if (timing.secureConnectionStart < 0)
return 0;
return resourceLoadTimeRelativeToAbsolute(timing.secureConnectionStart);
}
bool PageCache::canCachePageContainingThisFrame(Frame* frame)
{
for (Frame* child = frame->tree()->firstChild(); child; child = child->tree()->nextSibling()) {
if (!canCachePageContainingThisFrame(child))
return false;
}
FrameLoader* frameLoader = frame->loader();
DocumentLoader* documentLoader = frameLoader->documentLoader();
Document* document = frame->document();
return documentLoader
&& documentLoader->mainDocumentError().isNull()
// Do not cache error pages (these can be recognized as pages with substitute data or unreachable URLs).
&& !(documentLoader->substituteData().isValid() && !documentLoader->substituteData().failingURL().isEmpty())
&& (!frameLoader->subframeLoader()->containsPlugins() || frame->page()->settings()->pageCacheSupportsPlugins())
&& (!document->url().protocolIs("https") || (!documentLoader->response().cacheControlContainsNoCache() && !documentLoader->response().cacheControlContainsNoStore()))
&& (!document->domWindow() || !document->domWindow()->hasEventListeners(eventNames().unloadEvent))
#if ENABLE(SQL_DATABASE)
&& !DatabaseManager::manager().hasOpenDatabases(document)
#endif
#if ENABLE(SHARED_WORKERS)
&& !SharedWorkerRepository::hasSharedWorkers(document)
#endif
&& frameLoader->history()->currentItem()
&& !frameLoader->quickRedirectComing()
&& !documentLoader->isLoadingInAPISense()
&& !documentLoader->isStopping()
&& document->canSuspendActiveDOMObjects()
// FIXME: We should investigating caching frames that have an associated
// application cache. <rdar://problem/5917899> tracks that work.
&& documentLoader->applicationCacheHost()->canCacheInPageCache()
&& frameLoader->client()->canCachePage();
}
void InspectorApplicationCacheAgent::getApplicationCacheForFrame(ErrorString* errorString, const String& frameId, RefPtr<TypeBuilder::ApplicationCache::ApplicationCache>& applicationCache)
{
DocumentLoader* documentLoader = assertFrameWithDocumentLoader(errorString, frameId);
if (!documentLoader)
return;
ApplicationCacheHost* host = documentLoader->applicationCacheHost();
ApplicationCacheHost::CacheInfo info = host->applicationCacheInfo();
ApplicationCacheHost::ResourceInfoList resources;
host->fillResourceList(&resources);
applicationCache = buildObjectForApplicationCache(resources, info);
}