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<HistoryItem> HistoryController::createItem(bool useOriginal)
{
DocumentLoader* documentLoader = m_frame->loader()->documentLoader();
KURL unreachableURL = documentLoader ? documentLoader->unreachableURL() : KURL();
KURL url;
KURL originalURL;
if (!unreachableURL.isEmpty()) {
url = unreachableURL;
originalURL = unreachableURL;
} else {
originalURL = documentLoader ? documentLoader->originalURL() : KURL();
if (useOriginal)
url = originalURL;
else if (documentLoader)
url = documentLoader->requestURL();
}
LOG(History, "WebCoreHistory: Creating item for %s", url.string().ascii().data());
// Frames that have never successfully loaded any content
// may have no URL at all. Currently our history code can't
// deal with such things, so we nip that in the bud here.
// Later we may want to learn to live with nil for URL.
// See bug 3368236 and related bugs for more information.
if (url.isEmpty())
url = blankURL();
if (originalURL.isEmpty())
originalURL = blankURL();
Frame* parentFrame = m_frame->tree()->parent();
String parent = parentFrame ? parentFrame->tree()->uniqueName() : "";
String title = documentLoader ? documentLoader->title() : "";
RefPtr<HistoryItem> item = HistoryItem::create(url, m_frame->tree()->uniqueName(), parent, title);
item->setOriginalURLString(originalURL.string());
if (!unreachableURL.isEmpty() || !documentLoader || documentLoader->response().httpStatusCode() >= 400)
item->setLastVisitWasFailure(true);
// Save form state if this is a POST
if (documentLoader) {
if (useOriginal)
item->setFormInfoFromRequest(documentLoader->originalRequest());
else
item->setFormInfoFromRequest(documentLoader->request());
}
// Set the item for which we will save document state
m_frameLoadComplete = false;
m_previousItem = m_currentItem;
m_currentItem = item;
return item.release();
}
void WebFrameLoaderClient::updateGlobalHistory()
{
WebHistory* history = WebHistory::sharedHistory();
if (!history)
return;
DocumentLoader* loader = core(m_webFrame)->loader()->documentLoader();
history->visitedURL(loader->urlForHistory(), loader->title(), loader->request().httpMethod(), loader->urlForHistoryReflectsFailure());
updateGlobalHistoryRedirectLinks();
}
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);
}
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 HistoryController::initializeItem(HistoryItem* item)
{
DocumentLoader* documentLoader = m_frame->loader()->documentLoader();
ASSERT(documentLoader);
KURL unreachableURL = documentLoader->unreachableURL();
KURL url;
KURL originalURL;
if (!unreachableURL.isEmpty()) {
url = unreachableURL;
originalURL = unreachableURL;
} else {
url = documentLoader->url();
originalURL = documentLoader->originalURL();
}
// Frames that have never successfully loaded any content
// may have no URL at all. Currently our history code can't
// deal with such things, so we nip that in the bud here.
// Later we may want to learn to live with nil for URL.
// See bug 3368236 and related bugs for more information.
if (url.isEmpty())
url = blankURL();
if (originalURL.isEmpty())
originalURL = blankURL();
Frame* parentFrame = m_frame->tree()->parent();
String parent = parentFrame ? parentFrame->tree()->uniqueName() : "";
StringWithDirection title = documentLoader->title();
item->setURL(url);
item->setTarget(m_frame->tree()->uniqueName());
item->setParent(parent);
// FIXME: should store title directionality in history as well.
item->setTitle(title.string());
item->setOriginalURLString(originalURL.string());
if (!unreachableURL.isEmpty() || documentLoader->response().httpStatusCode() >= 400)
item->setLastVisitWasFailure(true);
// Save form state if this is a POST
item->setFormInfoFromRequest(documentLoader->request());
}
void HistoryController::updateCurrentItem()
{
if (!m_currentItem)
return;
DocumentLoader* documentLoader = m_frame->loader()->documentLoader();
if (!documentLoader->unreachableURL().isEmpty())
return;
if (m_currentItem->url() != documentLoader->url()) {
// We ended up on a completely different URL this time, so the HistoryItem
// needs to be re-initialized. Preserve the isTargetItem flag as it is a
// property of how this HistoryItem was originally created and is not
// dependent on the document.
bool isTargetItem = m_currentItem->isTargetItem();
m_currentItem->reset();
initializeItem(m_currentItem.get());
m_currentItem->setIsTargetItem(isTargetItem);
} else {
// Even if the final URL didn't change, the form data may have changed.
m_currentItem->setFormInfoFromRequest(documentLoader->request());
}
}
BlockedStatus ContentExtensionsBackend::processContentExtensionRulesForLoad(ResourceRequest& request, ResourceType resourceType, DocumentLoader& initiatingDocumentLoader)
{
Document* currentDocument = nullptr;
URL mainDocumentURL;
if (Frame* frame = initiatingDocumentLoader.frame()) {
currentDocument = frame->document();
if (initiatingDocumentLoader.isLoadingMainResource()
&& frame->isMainFrame()
&& resourceType == ResourceType::Document)
mainDocumentURL = request.url();
else if (Document* mainDocument = frame->mainFrame().document())
mainDocumentURL = mainDocument->url();
}
ResourceLoadInfo resourceLoadInfo = { request.url(), mainDocumentURL, resourceType };
Vector<ContentExtensions::Action> actions = actionsForResourceLoad(resourceLoadInfo);
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->extensionStyleSheets().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->extensionStyleSheets().maybeAddContentExtensionSheet(action.stringArgument(), *styleSheetContents);
}
break;
}
case ContentExtensions::ActionType::MakeHTTPS: {
const URL originalURL = request.url();
if (originalURL.protocolIs("http") && (!originalURL.hasPort() || isDefaultPortForProtocol(originalURL.port(), originalURL.protocol()))) {
URL newURL = originalURL;
newURL.setProtocol("https");
if (originalURL.hasPort())
newURL.setPort(defaultPortForProtocol("https"));
request.setURL(newURL);
if (resourceType == ResourceType::Document && initiatingDocumentLoader.isLoadingMainResource()) {
// This is to make sure the correct 'new' URL shows in the location bar.
initiatingDocumentLoader.request().setURL(newURL);
initiatingDocumentLoader.frameLoader()->client().dispatchDidChangeProvisionalURL();
}
if (currentDocument)
currentDocument->addConsoleMessage(MessageSource::ContentBlocker, MessageLevel::Info, makeString("Content blocker promoted URL from ", originalURL.string(), " to ", newURL.string()));
}
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()));
return BlockedStatus::Blocked;
}
return BlockedStatus::NotBlocked;
}
