void SVGUseElement::updateTargetReference() {
SVGURLReferenceResolver resolver(hrefString(), document());
m_elementIdentifier = resolver.fragmentIdentifier();
m_elementIdentifierIsLocal = resolver.isLocal();
if (m_elementIdentifierIsLocal) {
setDocumentResource(nullptr);
return;
}
KURL resolvedUrl = resolver.absoluteUrl();
if (m_elementIdentifier.isEmpty() ||
(m_resource &&
equalIgnoringFragmentIdentifier(resolvedUrl, m_resource->url())))
return;
FetchRequest request(ResourceRequest(resolvedUrl), localName());
setDocumentResource(
DocumentResource::fetchSVGDocument(request, document().fetcher()));
}
// Walk the frame tree and ensure that the URLs match the URLs in the item.
bool HistoryController::urlsMatchItem(HistoryItem* item) const
{
const KURL& currentURL = m_frame->loader()->documentLoader()->url();
if (!equalIgnoringFragmentIdentifier(currentURL, item->url()))
return false;
const HistoryItemVector& childItems = item->children();
unsigned size = childItems.size();
for (unsigned i = 0; i < size; ++i) {
Frame* childFrame = m_frame->tree()->child(childItems[i]->target());
if (childFrame && !childFrame->loader()->history()->urlsMatchItem(childItems[i].get()))
return false;
}
return true;
}
void Page::goToItem(HistoryItem* item, FrameLoadType type)
{
// Abort any current load if we're going to a history item
// Define what to do with any open database connections. By default we stop them and terminate the database thread.
DatabasePolicy databasePolicy = DatabasePolicyStop;
#if ENABLE(DATABASE)
// If we're navigating the history via a fragment on the same document, then we do not want to stop databases.
const KURL& currentURL = m_mainFrame->loader()->url();
const KURL& newURL = item->url();
if (newURL.hasFragmentIdentifier() && equalIgnoringFragmentIdentifier(currentURL, newURL))
databasePolicy = DatabasePolicyContinue;
#endif
m_mainFrame->loader()->stopAllLoaders(databasePolicy);
m_mainFrame->loader()->goToItem(item, type);
}
void FrameLoaderClientBlackBerry::dispatchDecidePolicyForNavigationAction(FramePolicyFunction function, const NavigationAction& action, const ResourceRequest& request, PassRefPtr<FormState>)
{
PolicyAction decision = PolicyIgnore;
const KURL& url = request.url();
if (!url.isNull()) {
// Fragment scrolls on the same page should always be handled internally.
// (Only count as a fragment scroll if we are scrolling to a #fragment url, not back to the top, and reloading
// the same url is not a fragment scroll even if it has a #fragment.)
const KURL& currentUrl = m_frame->document()->url();
bool isFragmentScroll = url.hasFragmentIdentifier() && url != currentUrl && equalIgnoringFragmentIdentifier(currentUrl, url);
decision = decidePolicyForExternalLoad(request, isFragmentScroll);
// Let the client have a chance to say whether this navigation should
// be ignored or not.
NetworkRequest platformRequest;
request.initializePlatformRequest(platformRequest, cookiesEnabled());
if (platformRequest.getTargetType() == NetworkRequest::TargetIsUnknown)
platformRequest.setTargetType(isMainFrame() ? NetworkRequest::TargetIsMainFrame : NetworkRequest::TargetIsSubframe);
if (isMainFrame() && !m_webPagePrivate->m_client->acceptNavigationRequest(
platformRequest, BlackBerry::Platform::NavigationType(action.type()))) {
if (action.type() == NavigationTypeFormSubmitted
|| action.type() == NavigationTypeFormResubmitted)
m_frame->loader()->resetMultipleFormSubmissionProtection();
if (action.type() == NavigationTypeLinkClicked && url.hasFragmentIdentifier()) {
ResourceRequest emptyRequest;
m_frame->loader()->activeDocumentLoader()->setLastCheckedRequest(emptyRequest);
}
decision = PolicyIgnore;
}
}
// If we abort here, dispatchDidCancelClientRedirect will not be called.
// So call it by hand.
if (decision == PolicyIgnore)
dispatchDidCancelClientRedirect();
(m_frame->loader()->policyChecker()->*function)(decision);
if (m_webPagePrivate->m_dumpRenderTree)
m_webPagePrivate->m_dumpRenderTree->didDecidePolicyForNavigationAction(action, request);
}
void InspectorPageAgent::resourceContent(ErrorString* errorString, Frame* frame, const KURL& url, String* result)
{
if (!frame) {
*errorString = "No frame to get resource content for";
return;
}
FrameLoader* frameLoader = frame->loader();
DocumentLoader* loader = frameLoader->documentLoader();
RefPtr<SharedBuffer> buffer;
bool success = false;
if (equalIgnoringFragmentIdentifier(url, loader->url()))
success = decodeMainResource(frame, result);
if (!success)
success = decodeCachedResource(cachedResource(frame, url), result);
if (!success)
*errorString = "No resource with given URL found";
}
void PrintContext::collectLinkedDestinations(Node* node)
{
for (Node* i = node->firstChild(); i; i = i->nextSibling())
collectLinkedDestinations(i);
if (!node->isLink() || !node->isElementNode())
return;
const AtomicString& href = toElement(node)->getAttribute(HTMLNames::hrefAttr);
if (href.isNull())
return;
KURL url = node->document().completeURL(href);
if (!url.isValid())
return;
if (url.hasFragmentIdentifier() && equalIgnoringFragmentIdentifier(url, node->document().baseURL())) {
String name = url.fragmentIdentifier();
Element* element = node->document().findAnchor(name);
if (element)
m_linkedDestinations.set(name, element);
}
}
// We don't use m_url, as it may not be the final URL that the object loads,
// depending on <param> values.
bool HTMLPlugInImageElement::allowedToLoadFrameURL(const String& url)
{
ASSERT(document());
ASSERT(document()->frame());
if (document()->frame()->page()->frameCount() >= Page::maxNumberOfFrames)
return false;
// We allow one level of self-reference because some sites depend on that.
// But we don't allow more than one.
KURL completeURL = document()->completeURL(url);
bool foundSelfReference = false;
for (Frame* frame = document()->frame(); frame; frame = frame->tree()->parent()) {
if (equalIgnoringFragmentIdentifier(frame->document()->url(), completeURL)) {
if (foundSelfReference)
return false;
foundSelfReference = true;
}
}
return true;
}
void InspectorResourceAgent::didReceiveResourceResponse(unsigned long identifier, DocumentLoader* loader, const ResourceResponse& response, ResourceLoader* resourceLoader)
{
if (!loader)
return;
String requestId = IdentifiersFactory::requestId(identifier);
RefPtr<TypeBuilder::Network::Response> resourceResponse = buildObjectForResourceResponse(response, loader);
bool isNotModified = response.httpStatusCode() == 304;
CachedResource* cachedResource = 0;
if (resourceLoader && !isNotModified)
cachedResource = resourceLoader->cachedResource();
if (!cachedResource)
cachedResource = InspectorPageAgent::cachedResource(loader->frame(), response.url());
if (cachedResource) {
// Use mime type from cached resource in case the one in response is empty.
if (resourceResponse && response.mimeType().isEmpty())
resourceResponse->setString(TypeBuilder::Network::Response::MimeType, cachedResource->response().mimeType());
m_resourcesData->addCachedResource(requestId, cachedResource);
}
InspectorPageAgent::ResourceType type = cachedResource ? InspectorPageAgent::cachedResourceType(*cachedResource) : InspectorPageAgent::OtherResource;
if (m_loadingXHRSynchronously || m_resourcesData->resourceType(requestId) == InspectorPageAgent::XHRResource)
type = InspectorPageAgent::XHRResource;
else if (m_resourcesData->resourceType(requestId) == InspectorPageAgent::ScriptResource)
type = InspectorPageAgent::ScriptResource;
else if (equalIgnoringFragmentIdentifier(response.url(), loader->url()) && !loader->isCommitted())
type = InspectorPageAgent::DocumentResource;
m_resourcesData->responseReceived(requestId, m_pageAgent->frameId(loader->frame()), response);
m_resourcesData->setResourceType(requestId, type);
m_frontend->responseReceived(requestId, m_pageAgent->frameId(loader->frame()), m_pageAgent->loaderId(loader), currentTime(), InspectorPageAgent::resourceTypeJson(type), resourceResponse);
// If we revalidated the resource and got Not modified, send content length following didReceiveResponse
// as there will be no calls to didReceiveData from the network stack.
if (isNotModified && cachedResource && cachedResource->encodedSize())
didReceiveData(identifier, 0, cachedResource->encodedSize(), 0);
}
bool History::canChangeToUrl(const KURL& url, SecurityOrigin* documentOrigin, const KURL& documentURL)
{
if (!url.isValid())
return false;
if (documentOrigin->isGrantedUniversalAccess())
return true;
// We allow sandboxed documents, `data:`/`file:` URLs, etc. to use
// 'pushState'/'replaceState' to modify the URL fragment: see
// https://crbug.com/528681 for the compatibility concerns.
if (documentOrigin->isUnique() || documentOrigin->isLocal())
return equalIgnoringFragmentIdentifier(url, documentURL);
if (!equalIgnoringPathQueryAndFragment(url, documentURL))
return false;
RefPtr<SecurityOrigin> requestedOrigin = SecurityOrigin::create(url);
if (requestedOrigin->isUnique() || !requestedOrigin->isSameSchemeHostPort(documentOrigin))
return false;
return true;
}
PassRefPtr<SharedBuffer> InspectorPageAgent::resourceData(Frame* frame, const KURL& url, String* textEncodingName)
{
RefPtr<SharedBuffer> buffer;
FrameLoader* frameLoader = frame->loader();
DocumentLoader* loader = frameLoader->documentLoader();
if (equalIgnoringFragmentIdentifier(url, loader->url())) {
*textEncodingName = frame->document()->inputEncoding();
buffer = frameLoader->documentLoader()->mainResourceData();
if (buffer)
return buffer;
}
CachedResource* cachedResource = InspectorPageAgent::cachedResource(frame, url);
if (!cachedResource)
return 0;
bool hasZeroSize;
bool prepared = prepareCachedResourceBuffer(cachedResource, &hasZeroSize);
if (!prepared)
return 0;
*textEncodingName = cachedResource->encoding();
return hasZeroSize ? SharedBuffer::create() : cachedResource->data();
}
bool HistoryItem::isCurrentDocument(Document* doc) const
{
// FIXME: We should find a better way to check if this is the current document.
return equalIgnoringFragmentIdentifier(url(), doc->url());
}
// We do same-document navigation if going to a different item and if either of the following is true:
// - The other item corresponds to the same document (for history entries created via pushState or fragment changes).
// - The other item corresponds to the same set of documents, including frames (for history entries created via regular navigation)
bool HistoryItem::shouldDoSameDocumentNavigationTo(HistoryItem* otherItem) const
{
if (this == otherItem)
return false;
if (stateObject() || otherItem->stateObject())
return documentSequenceNumber() == otherItem->documentSequenceNumber();
if ((url().hasFragmentIdentifier() || otherItem->url().hasFragmentIdentifier()) && equalIgnoringFragmentIdentifier(url(), otherItem->url()))
return documentSequenceNumber() == otherItem->documentSequenceNumber();
return hasSameDocumentTree(otherItem);
}
bool SVGURLReferenceResolver::isLocal() const {
return m_isLocal ||
equalIgnoringFragmentIdentifier(absoluteUrl(), m_document->url());
}
virtual void fire(Frame& frame) override
{
UserGestureIndicator gestureIndicator(wasUserGesture() ? DefinitelyProcessingUserGesture : DefinitelyNotProcessingUserGesture);
bool refresh = equalIgnoringFragmentIdentifier(frame.document()->url(), URL(ParsedURLString, url()));
frame.loader().changeLocation(securityOrigin(), URL(ParsedURLString, url()), referrer(), lockHistory(), lockBackForwardList(), refresh);
}