#include "config.h"
#include "core/loader/FrameLoader.h"
-#include "HTMLNames.h"
-#include "bindings/v8/DOMWrapperWorld.h"
-#include "bindings/v8/ScriptController.h"
-#include "bindings/v8/SerializedScriptValue.h"
+#include "bindings/core/v8/DOMWrapperWorld.h"
+#include "bindings/core/v8/ScriptController.h"
+#include "bindings/core/v8/SerializedScriptValue.h"
+#include "core/HTMLNames.h"
#include "core/dom/Document.h"
#include "core/dom/Element.h"
+#include "core/dom/ViewportDescription.h"
#include "core/editing/Editor.h"
#include "core/editing/UndoStack.h"
-#include "core/events/Event.h"
#include "core/events/PageTransitionEvent.h"
#include "core/fetch/FetchContext.h"
#include "core/fetch/ResourceFetcher.h"
#include "core/fetch/ResourceLoader.h"
-#include "core/frame/DOMWindow.h"
+#include "core/frame/LocalDOMWindow.h"
+#include "core/frame/FrameHost.h"
#include "core/frame/FrameView.h"
#include "core/frame/LocalFrame.h"
+#include "core/frame/PinchViewport.h"
+#include "core/frame/Settings.h"
#include "core/frame/csp/ContentSecurityPolicy.h"
#include "core/html/HTMLFormElement.h"
#include "core/html/HTMLFrameOwnerElement.h"
#include "core/html/parser/HTMLParserIdioms.h"
+#include "core/inspector/ConsoleMessage.h"
#include "core/inspector/InspectorController.h"
#include "core/inspector/InspectorInstrumentation.h"
#include "core/loader/DocumentLoadTiming.h"
#include "core/page/EventHandler.h"
#include "core/page/FrameTree.h"
#include "core/page/Page.h"
-#include "core/frame/Settings.h"
#include "core/page/WindowFeatures.h"
#include "core/page/scrolling/ScrollingCoordinator.h"
#include "core/xml/parser/XMLDocumentParser.h"
#include "platform/Logging.h"
#include "platform/UserGestureIndicator.h"
#include "platform/geometry/FloatRect.h"
-#include "platform/network/ContentSecurityPolicyResponseHeaders.h"
#include "platform/network/HTTPParsers.h"
#include "platform/network/ResourceRequest.h"
#include "platform/scroll/ScrollAnimator.h"
#include "platform/weborigin/SecurityOrigin.h"
#include "platform/weborigin/SecurityPolicy.h"
+#include "public/platform/WebURLRequest.h"
#include "wtf/TemporaryChange.h"
#include "wtf/text/CString.h"
#include "wtf/text/WTFString.h"
-namespace WebCore {
+using blink::WebURLRequest;
+
+namespace blink {
using namespace HTMLNames;
return type == FrameLoadTypeBackForward || type == FrameLoadTypeReload || type == FrameLoadTypeReloadFromOrigin;
}
-class FrameLoader::FrameProgressTracker {
-public:
- static PassOwnPtr<FrameProgressTracker> create(LocalFrame* frame) { return adoptPtr(new FrameProgressTracker(frame)); }
- ~FrameProgressTracker()
- {
- ASSERT(!m_inProgress || m_frame->page());
- if (m_inProgress)
- m_frame->page()->progress().progressCompleted(m_frame);
- }
-
- void progressStarted()
- {
- ASSERT(m_frame->page());
- if (!m_inProgress)
- m_frame->page()->progress().progressStarted(m_frame);
- m_inProgress = true;
- }
-
- void progressCompleted()
- {
- ASSERT(m_inProgress);
- ASSERT(m_frame->page());
- m_inProgress = false;
- m_frame->page()->progress().progressCompleted(m_frame);
- }
-
-private:
- FrameProgressTracker(LocalFrame* frame)
- : m_frame(frame)
- , m_inProgress(false)
- {
- }
-
- LocalFrame* m_frame;
- bool m_inProgress;
-};
-
-FrameLoader::FrameLoader(LocalFrame* frame, FrameLoaderClient* client)
+FrameLoader::FrameLoader(LocalFrame* frame)
: m_frame(frame)
- , m_client(client)
, m_mixedContentChecker(frame)
- , m_progressTracker(FrameProgressTracker::create(m_frame))
+ , m_progressTracker(ProgressTracker::create(frame))
, m_state(FrameStateProvisional)
, m_loadType(FrameLoadTypeStandard)
, m_fetchContext(FrameFetchContext::create(frame))
, m_inStopAllLoaders(false)
- , m_isComplete(false)
, m_checkTimer(this, &FrameLoader::checkTimerFired)
- , m_shouldCallCheckCompleted(false)
, m_didAccessInitialDocument(false)
, m_didAccessInitialDocumentTimer(this, &FrameLoader::didAccessInitialDocumentTimerFired)
, m_forcedSandboxFlags(SandboxNone)
FrameLoader::~FrameLoader()
{
+ // Verify that this FrameLoader has been detached.
+ ASSERT(!m_progressTracker);
+}
+
+void FrameLoader::trace(Visitor* visitor)
+{
+ visitor->trace(m_frame);
+ visitor->trace(m_mixedContentChecker);
+ visitor->trace(m_progressTracker);
+ visitor->trace(m_fetchContext);
}
void FrameLoader::init()
{
- m_provisionalDocumentLoader = m_client->createDocumentLoader(m_frame, ResourceRequest(KURL(ParsedURLString, emptyString())), SubstituteData());
+ ResourceRequest initialRequest(KURL(ParsedURLString, emptyString()));
+ initialRequest.setRequestContext(WebURLRequest::RequestContextInternal);
+ initialRequest.setFrameType(m_frame->isMainFrame() ? WebURLRequest::FrameTypeTopLevel : WebURLRequest::FrameTypeNested);
+ m_provisionalDocumentLoader = client()->createDocumentLoader(m_frame, initialRequest, SubstituteData());
m_provisionalDocumentLoader->startLoadingMainResource();
m_frame->document()->cancelParsing();
m_stateMachine.advanceTo(FrameLoaderStateMachine::DisplayingInitialEmptyDocument);
}
+FrameLoaderClient* FrameLoader::client() const
+{
+ return static_cast<FrameLoaderClient*>(m_frame->client());
+}
+
void FrameLoader::setDefersLoading(bool defers)
{
if (m_documentLoader)
m_deferredHistoryLoad = DeferredHistoryLoad();
}
m_frame->navigationScheduler().startTimer();
- startCheckCompleteTimer();
+ scheduleCheckCompleted();
}
}
void FrameLoader::stopLoading()
{
- m_isComplete = true; // to avoid calling completed() in finishedParsing()
-
if (m_frame->document() && m_frame->document()->parsing()) {
finishedParsing();
m_frame->document()->setParsing(false);
m_frame->navigationScheduler().cancel();
}
-void FrameLoader::markDocumentStateDirty()
-{
- Document* document = m_frame->document();
- document->setHistoryItemDocumentStateDirty(true);
- m_client->didUpdateCurrentHistoryItem();
-}
-
-void FrameLoader::saveDocumentState()
-{
- Document* document = m_frame->document();
- if (!m_currentItem || !document->historyItemDocumentStateDirty())
- return;
-
- if (m_currentItem->isCurrentDocument(document) && document->isActive())
- m_currentItem->setDocumentState(document->formElementsState());
-
- document->setHistoryItemDocumentStateDirty(false);
-}
-
void FrameLoader::saveScrollState()
{
if (!m_currentItem || !m_frame->view())
return;
m_currentItem->setScrollPoint(m_frame->view()->scrollPosition());
- if (m_frame->isMainFrame() && !m_frame->page()->inspectorController().deviceEmulationEnabled())
+
+ if (m_frame->settings()->pinchVirtualViewportEnabled())
+ m_currentItem->setPinchViewportScrollPoint(m_frame->host()->pinchViewport().visibleRect().location());
+ else
+ m_currentItem->setPinchViewportScrollPoint(FloatPoint(-1, -1));
+
+ if (m_frame->isMainFrame())
m_currentItem->setPageScaleFactor(m_frame->page()->pageScaleFactor());
- m_client->didUpdateCurrentHistoryItem();
+ client()->didUpdateCurrentHistoryItem();
}
void FrameLoader::clearScrollPositionAndViewState()
bool FrameLoader::closeURL()
{
- saveDocumentState();
saveScrollState();
// Should only send the pagehide event here if the current document exists.
void FrameLoader::didExplicitOpen()
{
- m_isComplete = false;
-
// Calling document.open counts as committing the first real document load.
if (!m_stateMachine.committedFirstRealDocumentLoad())
m_stateMachine.advanceTo(FrameLoaderStateMachine::CommittedFirstRealLoad);
void FrameLoader::clear()
{
+ // clear() is called during (Local)Frame finalization and when creating
+ // a new Document within it (DocumentLoader::createWriterFor().)
if (m_stateMachine.creatingInitialEmptyDocument())
return;
m_frame->document()->cancelParsing();
m_frame->document()->prepareForDestruction();
m_frame->document()->removeFocusedElementOfSubtree(m_frame->document());
-
m_frame->selection().prepareForDestruction();
m_frame->eventHandler().clear();
if (m_frame->view())
m_frame->script().enableEval();
- m_frame->navigationScheduler().clear();
+ m_frame->navigationScheduler().cancel();
m_checkTimer.stop();
- m_shouldCallCheckCompleted = false;
if (m_stateMachine.isDisplayingInitialEmptyDocument())
m_stateMachine.advanceTo(FrameLoaderStateMachine::CommittedFirstRealLoad);
}
+// This is only called by ScriptController::executeScriptIfJavaScriptURL
+// and always contains the result of evaluating a javascript: url.
+// This is the <iframe src="javascript:'html'"> case.
+void FrameLoader::replaceDocumentWhileExecutingJavaScriptURL(const String& source, Document* ownerDocument)
+{
+ if (!m_frame->document()->loader())
+ return;
+
+ // DocumentWriter::replaceDocumentWhileExecutingJavaScriptURL can cause the DocumentLoader to get deref'ed and possible destroyed,
+ // so protect it with a RefPtr.
+ RefPtr<DocumentLoader> documentLoader(m_frame->document()->loader());
+
+ UseCounter::count(*m_frame->document(), UseCounter::ReplaceDocumentViaJavaScriptURL);
+
+ // Prepare a DocumentInit before clearing the frame, because it may need to
+ // inherit an aliased security context.
+ DocumentInit init(m_frame->document()->url(), m_frame);
+ init.withNewRegistrationContext();
+
+ stopAllLoaders();
+ clear();
+
+ // clear() potentially detaches the frame from the document. The
+ // loading cannot continue in that case.
+ if (!m_frame->page())
+ return;
+
+ documentLoader->replaceDocumentWhileExecutingJavaScriptURL(init, source, ownerDocument);
+}
+
void FrameLoader::setHistoryItemStateForCommit(HistoryCommitType historyCommitType, bool isPushOrReplaceState, PassRefPtr<SerializedScriptValue> stateObject)
{
if (m_provisionalItem)
m_currentItem = m_provisionalItem.release();
- if (!m_currentItem || historyCommitType == StandardCommit)
+
+ if (!m_currentItem || historyCommitType == StandardCommit) {
m_currentItem = HistoryItem::create();
- else if (!isPushOrReplaceState && m_documentLoader->url() != m_currentItem->url())
- m_currentItem->generateNewSequenceNumbers();
+ } else if (!isPushOrReplaceState && m_documentLoader->url() != m_currentItem->url()) {
+ m_currentItem->generateNewItemSequenceNumber();
+ if (!equalIgnoringFragmentIdentifier(m_documentLoader->url(), m_currentItem->url()))
+ m_currentItem->generateNewDocumentSequenceNumber();
+ }
+
m_currentItem->setURL(m_documentLoader->urlForHistory());
+ m_currentItem->setDocumentState(m_frame->document()->formElementsState());
m_currentItem->setTarget(m_frame->tree().uniqueName());
if (isPushOrReplaceState)
m_currentItem->setStateObject(stateObject);
m_currentItem->setReferrer(Referrer(m_documentLoader->request().httpReferrer(), m_documentLoader->request().referrerPolicy()));
- m_currentItem->setFormInfoFromRequest(isPushOrReplaceState ? ResourceRequest() : m_documentLoader->request());
+ m_currentItem->setFormInfoFromRequest(m_documentLoader->request());
}
-static HistoryCommitType loadTypeToCommitType(FrameLoadType type, bool isValidHistoryURL)
+static HistoryCommitType loadTypeToCommitType(FrameLoadType type)
{
switch (type) {
case FrameLoadTypeStandard:
- return isValidHistoryURL ? StandardCommit : HistoryInertCommit;
+ return StandardCommit;
case FrameLoadTypeInitialInChildFrame:
return InitialCommitInChildFrame;
case FrameLoadTypeBackForward:
if (m_stateMachine.creatingInitialEmptyDocument())
return;
- bool isValidHistoryURL = !m_documentLoader->urlForHistory().isEmpty() && (!opener() || m_currentItem || !m_documentLoader->originalRequest().url().isEmpty());
- HistoryCommitType historyCommitType = loadTypeToCommitType(m_loadType, isValidHistoryURL);
+ HistoryCommitType historyCommitType = loadTypeToCommitType(m_loadType);
+ if (historyCommitType == StandardCommit && (m_documentLoader->urlForHistory().isEmpty() || (opener() && !m_currentItem && m_documentLoader->originalRequest().url().isEmpty())))
+ historyCommitType = HistoryInertCommit;
+ else if (historyCommitType == InitialCommitInChildFrame && (!m_frame->tree().top()->isLocalFrame() || MixedContentChecker::isMixedContent(toLocalFrame(m_frame->tree().top())->document()->securityOrigin(), m_documentLoader->url())))
+ historyCommitType = HistoryInertCommit;
setHistoryItemStateForCommit(historyCommitType);
if (!m_stateMachine.committedMultipleRealLoads() && m_loadType == FrameLoadTypeStandard)
m_stateMachine.advanceTo(FrameLoaderStateMachine::CommittedMultipleRealLoads);
- m_client->dispatchDidCommitLoad(m_frame, m_currentItem.get(), historyCommitType);
+ client()->dispatchDidCommitLoad(m_frame, m_currentItem.get(), historyCommitType);
InspectorInstrumentation::didCommitLoad(m_frame, m_documentLoader.get());
m_frame->page()->didCommitLoad(m_frame);
- dispatchDidClearWindowObjectsInAllWorlds();
-}
-
-static void didFailContentSecurityPolicyCheck(FrameLoader* loader)
-{
- // load event and stopAllLoaders can detach the LocalFrame, so protect it.
- RefPtr<LocalFrame> frame(loader->frame());
-
- // Move the page to a unique origin, and cancel the load.
- frame->document()->enforceSandboxFlags(SandboxOrigin);
- loader->stopAllLoaders();
-
- // Fire a load event, as timing attacks would otherwise reveal that the
- // frame was blocked. This way, it looks like every other cross-origin
- // page.
- if (HTMLFrameOwnerElement* ownerElement = frame->ownerElement())
- ownerElement->dispatchEvent(Event::create(EventTypeNames::load));
+ dispatchDidClearDocumentOfWindowObject();
}
void FrameLoader::didBeginDocument(bool dispatch)
{
- m_isComplete = false;
m_frame->document()->setReadyState(Document::Loading);
if (m_provisionalItem && m_loadType == FrameLoadTypeBackForward)
m_frame->domWindow()->statePopped(m_provisionalItem->stateObject());
if (dispatch)
- dispatchDidClearWindowObjectsInAllWorlds();
+ dispatchDidClearDocumentOfWindowObject();
- m_frame->document()->initContentSecurityPolicy(m_documentLoader ? ContentSecurityPolicyResponseHeaders(m_documentLoader->response()) : ContentSecurityPolicyResponseHeaders());
-
- if (!m_frame->document()->contentSecurityPolicy()->allowAncestors(m_frame)) {
- didFailContentSecurityPolicyCheck(this);
- return;
- }
+ m_frame->document()->initContentSecurityPolicy(m_documentLoader ? m_documentLoader->releaseContentSecurityPolicy() : ContentSecurityPolicy::create());
Settings* settings = m_frame->document()->settings();
if (settings) {
// This can be called from the LocalFrame's destructor, in which case we shouldn't protect ourselves
// because doing so will cause us to re-enter the destructor when protector goes out of scope.
// Null-checking the FrameView indicates whether or not we're in the destructor.
- RefPtr<LocalFrame> protector = m_frame->view() ? m_frame : 0;
+ RefPtrWillBeRawPtr<LocalFrame> protect(m_frame->view() ? m_frame.get() : nullptr);
- if (m_client)
- m_client->dispatchDidFinishDocumentLoad();
+ if (client())
+ client()->dispatchDidFinishDocumentLoad();
checkCompleted();
bool FrameLoader::allChildrenAreComplete() const
{
- for (LocalFrame* child = m_frame->tree().firstChild(); child; child = child->tree().nextSibling()) {
- if (!child->loader().m_isComplete)
+ for (Frame* child = m_frame->tree().firstChild(); child; child = child->tree().nextSibling()) {
+ if (!child->isLocalFrame())
+ continue;
+ LocalFrame* frame = toLocalFrame(child);
+ if (!frame->document()->isLoadCompleted() || frame->loader().m_provisionalDocumentLoader)
return false;
}
return true;
bool FrameLoader::allAncestorsAreComplete() const
{
- for (LocalFrame* ancestor = m_frame; ancestor; ancestor = ancestor->tree().parent()) {
- if (!ancestor->document()->loadEventFinished())
+ for (Frame* ancestor = m_frame; ancestor; ancestor = ancestor->tree().parent()) {
+ if (ancestor->isLocalFrame() && !toLocalFrame(ancestor)->document()->loadEventFinished())
return false;
}
return true;
void FrameLoader::checkCompleted()
{
- RefPtr<LocalFrame> protect(m_frame);
- m_shouldCallCheckCompleted = false;
+ RefPtrWillBeRawPtr<LocalFrame> protect(m_frame.get());
if (m_frame->view())
m_frame->view()->handleLoadCompleted();
- // Have we completed before?
- if (m_isComplete)
+ if (m_frame->document()->isLoadCompleted() && m_stateMachine.committedFirstRealDocumentLoad())
return;
// Are we still parsing?
return;
// OK, completed.
- m_isComplete = true;
m_frame->document()->setReadyState(Document::Complete);
if (m_frame->document()->loadEventStillNeeded())
m_frame->document()->implicitClose();
void FrameLoader::checkTimerFired(Timer<FrameLoader>*)
{
- RefPtr<LocalFrame> protect(m_frame);
-
if (Page* page = m_frame->page()) {
if (page->defersLoading())
return;
}
- if (m_shouldCallCheckCompleted)
- checkCompleted();
-}
-
-void FrameLoader::startCheckCompleteTimer()
-{
- if (!m_shouldCallCheckCompleted)
- return;
- if (m_checkTimer.isActive())
- return;
- m_checkTimer.startOneShot(0, FROM_HERE);
+ checkCompleted();
}
void FrameLoader::scheduleCheckCompleted()
{
- m_shouldCallCheckCompleted = true;
- startCheckCompleteTimer();
+ if (!m_checkTimer.isActive())
+ m_checkTimer.startOneShot(0, FROM_HERE);
}
-LocalFrame* FrameLoader::opener()
+Frame* FrameLoader::opener()
{
- // FIXME: Temporary hack to stage converting locations that really should be Frame.
- return m_client ? toLocalFrame(m_client->opener()) : 0;
+ return client() ? client()->opener() : 0;
}
void FrameLoader::setOpener(LocalFrame* opener)
{
// If the frame is already detached, the opener has already been cleared.
- if (m_client)
- m_client->setOpener(opener);
+ if (client())
+ client()->setOpener(opener);
}
bool FrameLoader::allowPlugins(ReasonForCallingAllowPlugins reason)
{
+ // With Oilpan, a FrameLoader might be accessed after the
+ // FrameHost has been detached. FrameClient will not be
+ // accessible, so bail early.
+ if (!client())
+ return false;
Settings* settings = m_frame->settings();
- bool allowed = m_client->allowPlugins(settings && settings->pluginsEnabled());
+ bool allowed = client()->allowPlugins(settings && settings->pluginsEnabled());
if (!allowed && reason == AboutToInstantiatePlugin)
- m_client->didNotAllowPlugins();
+ client()->didNotAllowPlugins();
return allowed;
}
-void FrameLoader::updateForSameDocumentNavigation(const KURL& newURL, SameDocumentNavigationSource sameDocumentNavigationSource, PassRefPtr<SerializedScriptValue> data, UpdateBackForwardListPolicy updateBackForwardList)
+void FrameLoader::updateForSameDocumentNavigation(const KURL& newURL, SameDocumentNavigationSource sameDocumentNavigationSource, PassRefPtr<SerializedScriptValue> data, FrameLoadType type)
{
// Update the data source's request with the new URL to fake the URL change
m_frame->document()->setURL(newURL);
- documentLoader()->updateForSameDocumentNavigation(newURL);
+ documentLoader()->updateForSameDocumentNavigation(newURL, sameDocumentNavigationSource);
// Generate start and stop notifications only when loader is completed so that we
// don't fire them for fragment redirection that happens in window.onload handler.
// See https://bugs.webkit.org/show_bug.cgi?id=31838
if (m_frame->document()->loadEventFinished())
- m_client->postProgressStartedNotification(NavigationWithinSameDocument);
+ client()->didStartLoading(NavigationWithinSameDocument);
+
+ HistoryCommitType historyCommitType = loadTypeToCommitType(type);
+ if (!m_currentItem)
+ historyCommitType = HistoryInertCommit;
- HistoryCommitType historyCommitType = updateBackForwardList == UpdateBackForwardList && m_currentItem ? StandardCommit : HistoryInertCommit;
setHistoryItemStateForCommit(historyCommitType, sameDocumentNavigationSource == SameDocumentNavigationHistoryApi, data);
- m_client->dispatchDidNavigateWithinPage(m_currentItem.get(), historyCommitType);
- m_client->dispatchDidReceiveTitle(m_frame->document()->title());
+ client()->dispatchDidNavigateWithinPage(m_currentItem.get(), historyCommitType);
+ client()->dispatchDidReceiveTitle(m_frame->document()->title());
if (m_frame->document()->loadEventFinished())
- m_client->postProgressFinishedNotification();
+ client()->didStopLoading();
}
-void FrameLoader::loadInSameDocument(const KURL& url, PassRefPtr<SerializedScriptValue> stateObject, UpdateBackForwardListPolicy updateBackForwardList, ClientRedirectPolicy clientRedirect)
+void FrameLoader::loadInSameDocument(const KURL& url, PassRefPtr<SerializedScriptValue> stateObject, FrameLoadType type, ClientRedirectPolicy clientRedirect)
{
// If we have a state object, we cannot also be a new navigation.
- ASSERT(!stateObject || updateBackForwardList == DoNotUpdateBackForwardList);
+ ASSERT(!stateObject || type == FrameLoadTypeBackForward);
// If we have a provisional request for a different document, a fragment scroll should cancel it.
if (m_provisionalDocumentLoader) {
if (m_provisionalDocumentLoader)
m_provisionalDocumentLoader->detachFromFrame();
m_provisionalDocumentLoader = nullptr;
+ if (!m_frame->host())
+ return;
}
- saveDocumentState();
+ m_loadType = type;
saveScrollState();
KURL oldURL = m_frame->document()->url();
m_frame->domWindow()->enqueueHashchangeEvent(oldURL, url);
}
m_documentLoader->setIsClientRedirect(clientRedirect == ClientRedirect);
- bool replacesCurrentHistoryItem = updateBackForwardList == DoNotUpdateBackForwardList;
- m_documentLoader->setReplacesCurrentHistoryItem(replacesCurrentHistoryItem);
- updateForSameDocumentNavigation(url, SameDocumentNavigationDefault, nullptr, updateBackForwardList);
+ m_documentLoader->setReplacesCurrentHistoryItem(m_loadType == FrameLoadTypeStandard);
+ updateForSameDocumentNavigation(url, SameDocumentNavigationDefault, nullptr, type);
m_frame->view()->setWasScrolledByUser(false);
- // It's important to model this as a load that starts and immediately finishes.
- // Otherwise, the parent frame may think we never finished loading.
- started();
-
// We need to scroll to the fragment whether or not a hash change occurred, since
// the user might have scrolled since the previous navigation.
scrollToFragmentWithParentBoundary(url);
-
- m_isComplete = false;
checkCompleted();
m_frame->domWindow()->statePopped(stateObject ? stateObject : SerializedScriptValue::nullValue());
void FrameLoader::completed()
{
- RefPtr<LocalFrame> protect(m_frame);
+ RefPtrWillBeRawPtr<LocalFrame> protect(m_frame.get());
- for (LocalFrame* descendant = m_frame->tree().traverseNext(m_frame); descendant; descendant = descendant->tree().traverseNext(m_frame))
- descendant->navigationScheduler().startTimer();
+ for (Frame* descendant = m_frame->tree().traverseNext(m_frame); descendant; descendant = descendant->tree().traverseNext(m_frame)) {
+ if (descendant->isLocalFrame())
+ toLocalFrame(descendant)->navigationScheduler().startTimer();
+ }
- if (LocalFrame* parent = m_frame->tree().parent())
- parent->loader().checkCompleted();
+ Frame* parent = m_frame->tree().parent();
+ if (parent && parent->isLocalFrame())
+ toLocalFrame(parent)->loader().checkCompleted();
if (m_frame->view())
m_frame->view()->maintainScrollPositionAtAnchor(0);
}
-void FrameLoader::started()
-{
- for (LocalFrame* frame = m_frame; frame; frame = frame->tree().parent())
- frame->loader().m_isComplete = false;
-}
-
void FrameLoader::setReferrerForFrameRequest(ResourceRequest& request, ShouldSendReferrer shouldSendReferrer, Document* originDocument)
{
if (shouldSendReferrer == NeverSendReferrer) {
request.setHTTPReferrer(Referrer(referrer, originDocument->referrerPolicy()));
RefPtr<SecurityOrigin> referrerOrigin = SecurityOrigin::createFromString(referrer);
- addHTTPOriginIfNeeded(request, referrerOrigin->toAtomicString());
+ request.addHTTPOriginIfNeeded(referrerOrigin->toAtomicString());
}
bool FrameLoader::isScriptTriggeredFormSubmissionInChildFrame(const FrameLoadRequest& request) const
FrameLoadType FrameLoader::determineFrameLoadType(const FrameLoadRequest& request)
{
- if (m_frame->tree().parent() && !m_stateMachine.startedFirstRealLoad())
+ if (m_frame->tree().parent() && !m_stateMachine.committedFirstRealDocumentLoad())
return FrameLoadTypeInitialInChildFrame;
if (!m_frame->tree().parent() && !m_frame->page()->backForward().backForwardListCount())
return FrameLoadTypeStandard;
return FrameLoadTypeBackForward;
if (request.resourceRequest().cachePolicy() == ReloadIgnoringCacheData)
return FrameLoadTypeReload;
+ if (request.resourceRequest().cachePolicy() == ReloadBypassingCache)
+ return FrameLoadTypeReloadFromOrigin;
if (request.lockBackForwardList() || isScriptTriggeredFormSubmissionInChildFrame(request))
return FrameLoadTypeRedirectWithLockedBackForwardList;
if (!request.originDocument() && request.resourceRequest().url() == m_documentLoader->urlForHistory())
bool FrameLoader::prepareRequestForThisFrame(FrameLoadRequest& request)
{
- // If no origin Document* was specified, skip security checks and assume the caller has fully initialized the FrameLoadRequest.
+ request.resourceRequest().setFrameType(m_frame->isMainFrame() ? WebURLRequest::FrameTypeTopLevel : WebURLRequest::FrameTypeNested);
+
+ // If no origin Document* was specified, skip remaining security checks and assume the caller has fully initialized the FrameLoadRequest.
if (!request.originDocument())
return true;
return request.formState() && action.shouldOpenInNewWindow();
}
+static WebURLRequest::RequestContext determineRequestContextFromNavigationType(const NavigationType navigationType)
+{
+ switch (navigationType) {
+ case NavigationTypeLinkClicked:
+ return WebURLRequest::RequestContextHyperlink;
+
+ case NavigationTypeOther:
+ return WebURLRequest::RequestContextLocation;
+
+ case NavigationTypeFormResubmitted:
+ case NavigationTypeFormSubmitted:
+ return WebURLRequest::RequestContextForm;
+
+ case NavigationTypeBackForward:
+ case NavigationTypeReload:
+ return WebURLRequest::RequestContextInternal;
+ }
+ ASSERT_NOT_REACHED();
+ return WebURLRequest::RequestContextHyperlink;
+}
+
void FrameLoader::load(const FrameLoadRequest& passedRequest)
{
ASSERT(m_frame->document());
- RefPtr<LocalFrame> protect(m_frame);
+ RefPtrWillBeRawPtr<LocalFrame> protect(m_frame.get());
if (m_inStopAllLoaders)
return;
if (!prepareRequestForThisFrame(request))
return;
- RefPtr<LocalFrame> targetFrame = request.formState() ? 0 : findFrameForNavigation(AtomicString(request.frameName()), request.formState() ? request.formState()->sourceDocument() : m_frame->document());
- if (targetFrame && targetFrame != m_frame) {
+ RefPtrWillBeRawPtr<LocalFrame> targetFrame = request.formState() ? 0 : findFrameForNavigation(AtomicString(request.frameName()), request.formState() ? request.formState()->sourceDocument() : m_frame->document());
+ if (targetFrame && targetFrame.get() != m_frame) {
request.setFrameName("_self");
targetFrame->loader().load(request);
if (Page* page = targetFrame->page())
FrameLoadType newLoadType = determineFrameLoadType(request);
NavigationAction action(request.resourceRequest(), newLoadType, request.formState(), request.triggeringEvent());
+ if (action.resourceRequest().requestContext() == WebURLRequest::RequestContextUnspecified)
+ action.mutableResourceRequest().setRequestContext(determineRequestContextFromNavigationType(action.type()));
if (shouldOpenInNewWindow(targetFrame.get(), request, action)) {
if (action.policy() == NavigationPolicyDownload)
- m_client->loadURLExternally(action.resourceRequest(), NavigationPolicyDownload);
+ client()->loadURLExternally(action.resourceRequest(), NavigationPolicyDownload);
else
createWindowForRequest(request, *m_frame, action.policy(), request.shouldSendReferrer());
return;
const KURL& url = request.resourceRequest().url();
if (!action.shouldOpenInNewWindow() && shouldPerformFragmentNavigation(request.formState(), request.resourceRequest().httpMethod(), newLoadType, url)) {
m_documentLoader->setTriggeringAction(action);
- loadInSameDocument(url, nullptr, newLoadType == FrameLoadTypeStandard && !shouldTreatURLAsSameAsCurrent(url) ? UpdateBackForwardList : DoNotUpdateBackForwardList, request.clientRedirect());
+ if (shouldTreatURLAsSameAsCurrent(url))
+ newLoadType = FrameLoadTypeRedirectWithLockedBackForwardList;
+ loadInSameDocument(url, nullptr, newLoadType, request.clientRedirect());
return;
}
bool sameURL = url == m_documentLoader->urlForHistory();
- loadWithNavigationAction(action, newLoadType, request.formState(), request.substituteData(), request.clientRedirect());
+ loadWithNavigationAction(action, newLoadType, request.formState(), request.substituteData(), request.shouldCheckMainWorldContentSecurityPolicy(), request.clientRedirect());
// Example of this case are sites that reload the same URL with a different cookie
// driving the generated content, or a master frame with links that drive a target
// frame, where the user has clicked on the same link repeatedly.
{
if (!shouldTreatURLAsSrcdocDocument(url))
return SubstituteData();
- String srcdoc = m_frame->ownerElement()->fastGetAttribute(srcdocAttr);
+ String srcdoc = m_frame->deprecatedLocalOwner()->fastGetAttribute(srcdocAttr);
ASSERT(!srcdoc.isNull());
CString encodedSrcdoc = srcdoc.utf8();
return SubstituteData(SharedBuffer::create(encodedSrcdoc.data(), encodedSrcdoc.length()), "text/html", "UTF-8", KURL());
if (!frame)
return;
- frame->document()->addConsoleMessage(SecurityMessageSource, ErrorMessageLevel, "Not allowed to load local resource: " + url);
+ frame->document()->addConsoleMessage(ConsoleMessage::create(SecurityMessageSource, ErrorMessageLevel, "Not allowed to load local resource: " + url));
}
-static ResourceRequest requestFromHistoryItem(HistoryItem* item, ResourceRequestCachePolicy cachePolicy)
+// static
+ResourceRequest FrameLoader::requestFromHistoryItem(HistoryItem* item, ResourceRequestCachePolicy cachePolicy)
{
RefPtr<FormData> formData = item->formData();
ResourceRequest request(item->url(), item->referrer());
request.setHTTPBody(formData);
request.setHTTPContentType(item->formContentType());
RefPtr<SecurityOrigin> securityOrigin = SecurityOrigin::createFromString(item->referrer().referrer);
- FrameLoader::addHTTPOriginIfNeeded(request, securityOrigin->toAtomicString());
+ request.addHTTPOriginIfNeeded(securityOrigin->toAtomicString());
}
return request;
}
-void FrameLoader::reload(ReloadPolicy reloadPolicy, const KURL& overrideURL, const AtomicString& overrideEncoding)
+void FrameLoader::reload(ReloadPolicy reloadPolicy, const KURL& overrideURL, const AtomicString& overrideEncoding, ClientRedirectPolicy clientRedirectPolicy)
{
if (!m_currentItem)
return;
- ResourceRequest request = requestFromHistoryItem(m_currentItem.get(), ReloadIgnoringCacheData);
+ ResourceRequestCachePolicy cachePolicy = reloadPolicy == EndToEndReload ? ReloadBypassingCache : ReloadIgnoringCacheData;
+ ResourceRequest request = requestFromHistoryItem(m_currentItem.get(), cachePolicy);
+ request.setFrameType(m_frame->isMainFrame() ? WebURLRequest::FrameTypeTopLevel : WebURLRequest::FrameTypeNested);
+ request.setRequestContext(WebURLRequest::RequestContextInternal);
+
+ // ClientRedirectPolicy is an indication that this load was triggered by
+ // some direct interaction with the page. If this reload is not a client
+ // redirect, we should reuse the referrer from the original load of the
+ // current document. If this reload is a client redirect (e.g., location.reload()),
+ // it was initiated by something in the current document and should
+ // therefore show the current document's url as the referrer.
+ if (clientRedirectPolicy == ClientRedirect)
+ request.setHTTPReferrer(Referrer(m_frame->document()->outgoingReferrer(), m_frame->document()->referrerPolicy()));
+
if (!overrideURL.isEmpty()) {
request.setURL(overrideURL);
request.clearHTTPReferrer();
}
+ request.setSkipServiceWorker(reloadPolicy == EndToEndReload);
FrameLoadType type = reloadPolicy == EndToEndReload ? FrameLoadTypeReloadFromOrigin : FrameLoadTypeReload;
- loadWithNavigationAction(NavigationAction(request, type), type, nullptr, SubstituteData(), NotClientRedirect, overrideEncoding);
+ loadWithNavigationAction(NavigationAction(request, type), type, nullptr, SubstituteData(), CheckContentSecurityPolicy, clientRedirectPolicy, overrideEncoding);
}
void FrameLoader::stopAllLoaders()
// Calling stopLoading() on the provisional document loader can blow away
// the frame from underneath.
- RefPtr<LocalFrame> protect(m_frame);
+ RefPtrWillBeRawPtr<LocalFrame> protect(m_frame.get());
m_inStopAllLoaders = true;
- for (RefPtr<LocalFrame> child = m_frame->tree().firstChild(); child; child = child->tree().nextSibling())
- child->loader().stopAllLoaders();
+ for (RefPtrWillBeRawPtr<Frame> child = m_frame->tree().firstChild(); child; child = child->tree().nextSibling()) {
+ if (child->isLocalFrame())
+ toLocalFrame(child.get())->loader().stopAllLoaders();
+ }
if (m_provisionalDocumentLoader)
m_provisionalDocumentLoader->stopLoading();
if (m_documentLoader)
// detachFromParent() can be called multiple times on same LocalFrame, which
// means we may no longer have a FrameLoaderClient to talk to.
- if (m_client)
- m_client->didStopAllLoaders();
+ if (client())
+ client()->didStopAllLoaders();
}
void FrameLoader::didAccessInitialDocument()
void FrameLoader::didAccessInitialDocumentTimerFired(Timer<FrameLoader>*)
{
- m_client->didAccessInitialDocument();
+ if (client())
+ client()->didAccessInitialDocument();
}
void FrameLoader::notifyIfInitialDocumentAccessed()
}
}
-bool FrameLoader::isLoading() const
-{
- if (m_provisionalDocumentLoader)
- return true;
- return m_documentLoader && m_documentLoader->isLoading();
-}
-
void FrameLoader::commitProvisionalLoad()
{
- ASSERT(m_client->hasWebView());
+ ASSERT(client()->hasWebView());
ASSERT(m_state == FrameStateProvisional);
RefPtr<DocumentLoader> pdl = m_provisionalDocumentLoader;
- RefPtr<LocalFrame> protect(m_frame);
+ RefPtrWillBeRawPtr<LocalFrame> protect(m_frame.get());
// Check if the destination page is allowed to access the previous page's timing information.
if (m_frame->document()) {
// or the two will stomp each other.
// detachChildren will similarly trigger child frame unload event handlers.
if (m_documentLoader) {
- m_client->dispatchWillClose();
+ client()->dispatchWillClose();
closeURL();
}
- detachChildren();
+ m_frame->detachChildren();
if (pdl != m_provisionalDocumentLoader)
return;
if (m_documentLoader)
if (isLoadingMainFrame())
m_frame->page()->chrome().client().needTouchEvents(false);
- m_client->transitionToCommittedForNewPage();
+ client()->transitionToCommittedForNewPage();
m_frame->navigationScheduler().cancel();
m_frame->editor().clearLastEditCommand();
// its frame is not in a consistent state for rendering, so avoid setJSStatusBarText
// since it may cause clients to attempt to render the frame.
if (!m_stateMachine.creatingInitialEmptyDocument()) {
- DOMWindow* window = m_frame->domWindow();
+ LocalDOMWindow* window = m_frame->domWindow();
window->setStatus(String());
window->setDefaultStatus(String());
}
- started();
}
bool FrameLoader::isLoadingMainFrame() const
// If you're thinking of using it elsewhere, stop right now and reconsider your life.
static bool isDocumentDoneLoading(Document* document)
{
+ if (!document->loader())
+ return true;
if (document->loader()->isLoadingMainResource())
return false;
if (!document->loadEventFinished()) {
bool FrameLoader::checkLoadCompleteForThisFrame()
{
- ASSERT(m_client->hasWebView());
- RefPtr<LocalFrame> protect(m_frame);
+ ASSERT(client()->hasWebView());
+ RefPtrWillBeRawPtr<LocalFrame> protect(m_frame.get());
+
+ bool allChildrenAreDoneLoading = true;
+ for (RefPtrWillBeRawPtr<Frame> child = m_frame->tree().firstChild(); child; child = child->tree().nextSibling()) {
+ if (child->isLocalFrame())
+ allChildrenAreDoneLoading &= toLocalFrame(child.get())->loader().checkLoadCompleteForThisFrame();
+ }
if (m_state == FrameStateProvisional && m_provisionalDocumentLoader) {
const ResourceError& error = m_provisionalDocumentLoader->mainDocumentError();
if (error.isNull())
return false;
RefPtr<DocumentLoader> loader = m_provisionalDocumentLoader;
- m_client->dispatchDidFailProvisionalLoad(error);
+ client()->dispatchDidFailProvisionalLoad(error);
if (loader != m_provisionalDocumentLoader)
return false;
m_provisionalDocumentLoader->detachFromFrame();
m_provisionalDocumentLoader = nullptr;
m_progressTracker->progressCompleted();
m_state = FrameStateComplete;
+ checkCompleted();
return true;
}
- bool allChildrenAreDoneLoading = true;
- for (LocalFrame* child = m_frame->tree().firstChild(); child; child = child->tree().nextSibling())
- allChildrenAreDoneLoading &= child->loader().checkLoadCompleteForThisFrame();
if (!allChildrenAreDoneLoading)
return false;
return true;
m_progressTracker->progressCompleted();
+ m_frame->domWindow()->finishedLoading();
const ResourceError& error = m_documentLoader->mainDocumentError();
- if (!error.isNull())
- m_client->dispatchDidFailLoad(error);
- else
- m_client->dispatchDidFinishLoad();
+ if (!error.isNull()) {
+ client()->dispatchDidFailLoad(error);
+ } else {
+ // Report mobile vs. desktop page statistics. This will only report on Android.
+ if (m_frame->isMainFrame())
+ m_frame->document()->viewportDescription().reportMobilePageStats(m_frame);
+
+ client()->dispatchDidFinishLoad();
+ }
m_loadType = FrameLoadTypeStandard;
return true;
}
// page height increases, 3. ignore clamp detection after load completes
// because that may be because the page will never reach its previous
// height.
- bool canRestoreWithoutClamping = view->clampOffsetAtScale(m_currentItem->scrollPoint(), m_currentItem->pageScaleFactor()) == m_currentItem->scrollPoint();
+ float mainFrameScale = m_frame->settings()->pinchVirtualViewportEnabled() ? 1 : m_currentItem->pageScaleFactor();
+ bool canRestoreWithoutClamping = view->clampOffsetAtScale(m_currentItem->scrollPoint(), mainFrameScale) == m_currentItem->scrollPoint();
bool canRestoreWithoutAnnoyingUser = !view->wasScrolledByUser() && (canRestoreWithoutClamping || m_state == FrameStateComplete);
if (!canRestoreWithoutAnnoyingUser)
return;
- if (m_frame->isMainFrame() && m_currentItem->pageScaleFactor())
- m_frame->page()->setPageScaleFactor(m_currentItem->pageScaleFactor(), m_currentItem->scrollPoint());
- else
+ if (m_frame->isMainFrame() && m_currentItem->pageScaleFactor()) {
+ FloatPoint pinchViewportOffset(m_currentItem->pinchViewportScrollPoint());
+ IntPoint frameScrollOffset(m_currentItem->scrollPoint());
+
+ m_frame->page()->setPageScaleFactor(m_currentItem->pageScaleFactor(), frameScrollOffset);
+
+ if (m_frame->settings()->pinchVirtualViewportEnabled()) {
+ // If the pinch viewport's offset is (-1, -1) it means the history item
+ // is an old version of HistoryItem so distribute the scroll between
+ // the main frame and the pinch viewport as best as we can.
+ // FIXME(bokan): This legacy distribution can be removed once the virtual viewport
+ // pinch path is enabled on all platforms for at least one release.
+ if (pinchViewportOffset.x() == -1 && pinchViewportOffset.y() == -1)
+ pinchViewportOffset = FloatPoint(frameScrollOffset - view->scrollPosition());
+
+ m_frame->host()->pinchViewport().setLocation(pinchViewportOffset);
+ }
+ } else {
view->setScrollPositionNonProgrammatically(m_currentItem->scrollPoint());
+ }
if (m_frame->isMainFrame()) {
if (ScrollingCoordinator* scrollingCoordinator = m_frame->page()->scrollingCoordinator())
}
}
-void FrameLoader::detachChildren()
-{
- typedef Vector<RefPtr<LocalFrame> > FrameVector;
- FrameVector childrenToDetach;
- childrenToDetach.reserveCapacity(m_frame->tree().childCount());
- for (LocalFrame* child = m_frame->tree().lastChild(); child; child = child->tree().previousSibling())
- childrenToDetach.append(child);
- FrameVector::iterator end = childrenToDetach.end();
- for (FrameVector::iterator it = childrenToDetach.begin(); it != end; ++it)
- (*it)->loader().detachFromParent();
-}
-
-void FrameLoader::closeAndRemoveChild(LocalFrame* child)
-{
- child->setView(nullptr);
- if (child->ownerElement() && child->page())
- child->page()->decrementSubframeCount();
- child->willDetachFrameHost();
- child->loader().detachClient();
-}
-
// Called every time a resource is completely loaded or an error is received.
void FrameLoader::checkLoadComplete()
{
- ASSERT(m_client->hasWebView());
- if (Page* page = m_frame->page())
- page->mainFrame()->loader().checkLoadCompleteForThisFrame();
-}
-
-void FrameLoader::checkLoadComplete(DocumentLoader* documentLoader)
-{
- if (documentLoader)
- documentLoader->checkLoadComplete();
- checkLoadComplete();
-}
-
-int FrameLoader::numPendingOrLoadingRequests(bool recurse) const
-{
- if (!recurse)
- return m_frame->document()->fetcher()->requestCount();
-
- int count = 0;
- for (LocalFrame* frame = m_frame; frame; frame = frame->tree().traverseNext(m_frame))
- count += frame->document()->fetcher()->requestCount();
- return count;
+ ASSERT(client()->hasWebView());
+ if (Page* page = m_frame->page()) {
+ if (page->mainFrame()->isLocalFrame())
+ page->deprecatedLocalMainFrame()->loader().checkLoadCompleteForThisFrame();
+ }
}
String FrameLoader::userAgent(const KURL& url) const
{
- String userAgent = m_client->userAgent(url);
+ String userAgent = client()->userAgent(url);
InspectorInstrumentation::applyUserAgentOverride(m_frame, &userAgent);
return userAgent;
}
-void FrameLoader::frameDetached()
-{
- // stopAllLoaders can detach the LocalFrame, so protect it.
- RefPtr<LocalFrame> protect(m_frame);
- stopAllLoaders();
- detachFromParent();
-}
-
void FrameLoader::detachFromParent()
{
- // stopAllLoaders can detach the LocalFrame, so protect it.
- RefPtr<LocalFrame> protect(m_frame);
-
- closeURL();
- detachChildren();
- // stopAllLoaders() needs to be called after detachChildren(), because detachedChildren()
- // will trigger the unload event handlers of any child frames, and those event
- // handlers might start a new subresource load in this frame.
- stopAllLoaders();
+#if !ENABLE(OILPAN)
+ // The caller must protect a reference to m_frame.
+ ASSERT(m_frame->refCount() > 1);
+#endif
InspectorInstrumentation::frameDetachedFromParent(m_frame);
m_documentLoader->detachFromFrame();
m_documentLoader = nullptr;
- if (!m_client)
+ if (!client())
return;
// FIXME: All this code belongs up in Page.
- if (LocalFrame* parent = m_frame->tree().parent()) {
- parent->loader().closeAndRemoveChild(m_frame);
- parent->loader().scheduleCheckCompleted();
+ Frame* parent = m_frame->tree().parent();
+ if (parent && parent->isLocalFrame()) {
+ m_frame->setView(nullptr);
+ // FIXME: Shouldn't need to check if page() is null here.
+ if (m_frame->owner() && m_frame->page())
+ m_frame->page()->decrementSubframeCount();
+ m_frame->willDetachFrameHost();
+ detachClient();
+ toLocalFrame(parent)->loader().scheduleCheckCompleted();
} else {
m_frame->setView(nullptr);
m_frame->willDetachFrameHost();
detachClient();
}
m_frame->detachFromFrameHost();
-
}
void FrameLoader::detachClient()
{
- ASSERT(m_client);
+ ASSERT(client());
// Finish all cleanup work that might require talking to the embedder.
+ m_progressTracker->dispose();
m_progressTracker.clear();
setOpener(0);
// Notify ScriptController that the frame is closing, since its cleanup ends up calling
- // back to FrameLoaderClient via V8WindowShell.
+ // back to FrameLoaderClient via WindowProxy.
m_frame->script().clearForClose();
- // After this, we must no longer talk to the client since this clears
- // its owning reference back to our owning LocalFrame.
- m_client->detachedFromParent();
- m_client = 0;
-}
-
-void FrameLoader::addHTTPOriginIfNeeded(ResourceRequest& request, const AtomicString& origin)
-{
- if (!request.httpOrigin().isEmpty())
- return; // Request already has an Origin header.
-
- // Don't send an Origin header for GET or HEAD to avoid privacy issues.
- // For example, if an intranet page has a hyperlink to an external web
- // site, we don't want to include the Origin of the request because it
- // will leak the internal host name. Similar privacy concerns have lead
- // to the widespread suppression of the Referer header at the network
- // layer.
- if (request.httpMethod() == "GET" || request.httpMethod() == "HEAD")
- return;
-
- // For non-GET and non-HEAD methods, always send an Origin header so the
- // server knows we support this feature.
-
- if (origin.isEmpty()) {
- // If we don't know what origin header to attach, we attach the value
- // for an empty origin.
- request.setHTTPOrigin(SecurityOrigin::createUnique()->toAtomicString());
- return;
+ // client() should never be null because that means we somehow re-entered
+ // the frame detach code... but it is sometimes.
+ // FIXME: Understand why this is happening so we can document this insanity.
+ if (client()) {
+ // After this, we must no longer talk to the client since this clears
+ // its owning reference back to our owning LocalFrame.
+ client()->detachedFromParent();
+ m_frame->clearClient();
}
-
- request.setHTTPOrigin(origin);
}
void FrameLoader::receivedMainResourceError(const ResourceError& error)
{
// Retain because the stop may release the last reference to it.
- RefPtr<LocalFrame> protect(m_frame);
+ RefPtrWillBeRawPtr<LocalFrame> protect(m_frame.get());
if (m_frame->document()->parser())
m_frame->document()->parser()->stopParsing();
// FIXME: We really ought to be able to just check for isCancellation() here, but there are some
// ResourceErrors that setIsCancellation() but aren't created by ResourceError::cancelledError().
ResourceError c(ResourceError::cancelledError(KURL()));
- if ((error.errorCode() != c.errorCode() || error.domain() != c.domain()) && m_frame->ownerElement())
- m_frame->ownerElement()->renderFallbackContent();
+ if ((error.errorCode() != c.errorCode() || error.domain() != c.domain()) && m_frame->owner()) {
+ // FIXME: For now, fallback content doesn't work cross process.
+ ASSERT(m_frame->owner()->isLocal());
+ m_frame->deprecatedLocalOwner()->renderFallbackContent();
+ }
checkCompleted();
if (m_frame->page())
return;
// Leaking scroll position to a cross-origin ancestor would permit the so-called "framesniffing" attack.
- RefPtr<LocalFrame> boundaryFrame(url.hasFragmentIdentifier() ? m_frame->document()->findUnsafeParentScrollPropagationBoundary() : 0);
+ RefPtrWillBeRawPtr<LocalFrame> boundaryFrame = url.hasFragmentIdentifier() ? m_frame->document()->findUnsafeParentScrollPropagationBoundary() : 0;
if (boundaryFrame)
boundaryFrame->view()->setSafeToPropagateScrollToParent(false);
return true;
// Store all references to each subframe in advance since beforeunload's event handler may modify frame
- Vector<RefPtr<LocalFrame> > targetFrames;
+ WillBeHeapVector<RefPtrWillBeMember<LocalFrame> > targetFrames;
targetFrames.append(m_frame);
- for (LocalFrame* child = m_frame->tree().firstChild(); child; child = child->tree().traverseNext(m_frame))
- targetFrames.append(child);
+ for (Frame* child = m_frame->tree().firstChild(); child; child = child->tree().traverseNext(m_frame)) {
+ // FIXME: There is not yet any way to dispatch events to out-of-process frames.
+ if (child->isLocalFrame())
+ targetFrames.append(toLocalFrame(child));
+ }
bool shouldClose = false;
{
return shouldClose;
}
-void FrameLoader::loadWithNavigationAction(const NavigationAction& action, FrameLoadType type, PassRefPtr<FormState> formState, const SubstituteData& substituteData, ClientRedirectPolicy clientRedirect, const AtomicString& overrideEncoding)
+bool FrameLoader::validateTransitionNavigationMode()
{
- ASSERT(m_client->hasWebView());
+ if (frame()->document()->inQuirksMode()) {
+ frame()->document()->addConsoleMessage(ConsoleMessage::create(JSMessageSource, ErrorMessageLevel, "Ignoring transition elements due to quirks mode."));
+ return false;
+ }
+
+ // FIXME(oysteine): Also check for width=device-width here, to avoid zoom/scaling issues.
+ return true;
+}
+
+bool FrameLoader::dispatchNavigationTransitionData()
+{
+ Vector<Document::TransitionElementData> elementData;
+ frame()->document()->getTransitionElementData(elementData);
+ if (elementData.isEmpty() || !validateTransitionNavigationMode())
+ return false;
+
+ Vector<Document::TransitionElementData>::iterator iter = elementData.begin();
+ for (; iter != elementData.end(); ++iter)
+ client()->dispatchAddNavigationTransitionData(iter->scope, iter->selector, iter->markup);
+
+ return true;
+}
+
+void FrameLoader::loadWithNavigationAction(const NavigationAction& action, FrameLoadType type, PassRefPtrWillBeRawPtr<FormState> formState, const SubstituteData& substituteData, ContentSecurityPolicyCheck shouldCheckMainWorldContentSecurityPolicy, ClientRedirectPolicy clientRedirect, const AtomicString& overrideEncoding)
+{
+ ASSERT(client()->hasWebView());
if (m_frame->document()->pageDismissalEventBeingDispatched() != Document::NoDismissal)
return;
const ResourceRequest& request = action.resourceRequest();
- if (!m_stateMachine.startedFirstRealLoad())
- m_stateMachine.advanceTo(FrameLoaderStateMachine::StartedFirstRealLoad);
-
// The current load should replace the history item if it is the first real
// load of the frame.
bool replacesCurrentHistoryItem = false;
replacesCurrentHistoryItem = true;
}
- m_policyDocumentLoader = m_client->createDocumentLoader(m_frame, request, substituteData.isValid() ? substituteData : defaultSubstituteDataForURL(request.url()));
+ m_policyDocumentLoader = client()->createDocumentLoader(m_frame, request, substituteData.isValid() ? substituteData : defaultSubstituteDataForURL(request.url()));
m_policyDocumentLoader->setTriggeringAction(action);
m_policyDocumentLoader->setReplacesCurrentHistoryItem(replacesCurrentHistoryItem);
m_policyDocumentLoader->setIsClientRedirect(clientRedirect == ClientRedirect);
- if (LocalFrame* parent = m_frame->tree().parent())
- m_policyDocumentLoader->setOverrideEncoding(parent->loader().documentLoader()->overrideEncoding());
+ Frame* parent = m_frame->tree().parent();
+ if (parent && parent->isLocalFrame())
+ m_policyDocumentLoader->setOverrideEncoding(toLocalFrame(parent)->loader().documentLoader()->overrideEncoding());
else if (!overrideEncoding.isEmpty())
m_policyDocumentLoader->setOverrideEncoding(overrideEncoding);
else if (m_documentLoader)
m_policyDocumentLoader->setOverrideEncoding(m_documentLoader->overrideEncoding());
+
+ bool isTransitionNavigation = false;
+ if (RuntimeEnabledFeatures::navigationTransitionsEnabled() && type != FrameLoadTypeReload && type != FrameLoadTypeReloadFromOrigin && type != FrameLoadTypeSame)
+ isTransitionNavigation = dispatchNavigationTransitionData();
+
// stopAllLoaders can detach the LocalFrame, so protect it.
- RefPtr<LocalFrame> protect(m_frame);
- if ((!m_policyDocumentLoader->shouldContinueForNavigationPolicy(request) || !shouldClose()) && m_policyDocumentLoader) {
+ RefPtrWillBeRawPtr<LocalFrame> protect(m_frame.get());
+ if ((!m_policyDocumentLoader->shouldContinueForNavigationPolicy(request, shouldCheckMainWorldContentSecurityPolicy, isTransitionNavigation) || !shouldClose()) && m_policyDocumentLoader) {
m_policyDocumentLoader->detachFromFrame();
m_policyDocumentLoader = nullptr;
+ checkCompleted();
return;
}
- // A new navigation is in progress, so don't clear the history's provisional item.
- stopAllLoaders();
+ if (m_provisionalDocumentLoader) {
+ m_provisionalDocumentLoader->stopLoading();
+ if (m_provisionalDocumentLoader)
+ m_provisionalDocumentLoader->detachFromFrame();
+ m_provisionalDocumentLoader = nullptr;
+ }
+ m_checkTimer.stop();
// <rdar://problem/6250856> - In certain circumstances on pages with multiple frames, stopAllLoaders()
// might detach the current FrameLoader, in which case we should bail on this newly defunct load.
m_state = FrameStateProvisional;
if (formState)
- m_client->dispatchWillSubmitForm(formState->form());
+ client()->dispatchWillSubmitForm(formState->form());
m_progressTracker->progressStarted();
if (m_provisionalDocumentLoader->isClientRedirect())
m_provisionalDocumentLoader->appendRedirect(m_frame->document()->url());
m_provisionalDocumentLoader->appendRedirect(m_provisionalDocumentLoader->request().url());
- m_client->dispatchDidStartProvisionalLoad();
+ client()->dispatchDidStartProvisionalLoad(isTransitionNavigation);
ASSERT(m_provisionalDocumentLoader);
m_provisionalDocumentLoader->startLoadingMainResource();
}
{
UseCounter::count(m_frame->domWindow()->document(), UseCounter::XFrameOptions);
- LocalFrame* topFrame = m_frame->tree().top();
+ Frame* topFrame = m_frame->tree().top();
if (m_frame == topFrame)
return false;
case XFrameOptionsSameOrigin: {
UseCounter::count(m_frame->domWindow()->document(), UseCounter::XFrameOptionsSameOrigin);
RefPtr<SecurityOrigin> origin = SecurityOrigin::create(url);
- if (!origin->isSameSchemeHostPort(topFrame->document()->securityOrigin()))
+ // Out-of-process ancestors are always a different origin.
+ if (!topFrame->isLocalFrame() || !origin->isSameSchemeHostPort(toLocalFrame(topFrame)->document()->securityOrigin()))
return true;
- for (LocalFrame* frame = m_frame->tree().parent(); frame; frame = frame->tree().parent()) {
- if (!origin->isSameSchemeHostPort(frame->document()->securityOrigin())) {
+ for (Frame* frame = m_frame->tree().parent(); frame; frame = frame->tree().parent()) {
+ if (!frame->isLocalFrame() || !origin->isSameSchemeHostPort(toLocalFrame(frame)->document()->securityOrigin())) {
UseCounter::count(m_frame->domWindow()->document(), UseCounter::XFrameOptionsSameOriginWithBadAncestorChain);
break;
}
return true;
case XFrameOptionsAllowAll:
return false;
- case XFrameOptionsConflict:
- m_frame->document()->addConsoleMessageWithRequestIdentifier(JSMessageSource, ErrorMessageLevel, "Multiple 'X-Frame-Options' headers with conflicting values ('" + content + "') encountered when loading '" + url.elidedString() + "'. Falling back to 'DENY'.", requestIdentifier);
+ case XFrameOptionsConflict: {
+ RefPtrWillBeRawPtr<ConsoleMessage> consoleMessage = ConsoleMessage::create(JSMessageSource, ErrorMessageLevel, "Multiple 'X-Frame-Options' headers with conflicting values ('" + content + "') encountered when loading '" + url.elidedString() + "'. Falling back to 'DENY'.");
+ consoleMessage->setRequestIdentifier(requestIdentifier);
+ m_frame->document()->addConsoleMessage(consoleMessage.release());
return true;
- case XFrameOptionsInvalid:
- m_frame->document()->addConsoleMessageWithRequestIdentifier(JSMessageSource, ErrorMessageLevel, "Invalid 'X-Frame-Options' header encountered when loading '" + url.elidedString() + "': '" + content + "' is not a recognized directive. The header will be ignored.", requestIdentifier);
+ }
+ case XFrameOptionsInvalid: {
+ RefPtrWillBeRawPtr<ConsoleMessage> consoleMessage = ConsoleMessage::create(JSMessageSource, ErrorMessageLevel, "Invalid 'X-Frame-Options' header encountered when loading '" + url.elidedString() + "': '" + content + "' is not a recognized directive. The header will be ignored.");
+ consoleMessage->setRequestIdentifier(requestIdentifier);
+ m_frame->document()->addConsoleMessage(consoleMessage.release());
return false;
+ }
default:
ASSERT_NOT_REACHED();
return false;
{
if (!equalIgnoringCase(url.string(), "about:srcdoc"))
return false;
- HTMLFrameOwnerElement* ownerElement = m_frame->ownerElement();
+ HTMLFrameOwnerElement* ownerElement = m_frame->deprecatedLocalOwner();
if (!isHTMLIFrameElement(ownerElement))
return false;
return ownerElement->fastHasAttribute(srcdocAttr);
LocalFrame* FrameLoader::findFrameForNavigation(const AtomicString& name, Document* activeDocument)
{
ASSERT(activeDocument);
- LocalFrame* frame = m_frame->tree().find(name);
- if (!activeDocument->canNavigate(frame))
+ Frame* frame = m_frame->tree().find(name);
+ if (!frame || !frame->isLocalFrame() || !activeDocument->canNavigate(toLocalFrame(*frame)))
return 0;
- return frame;
+ return toLocalFrame(frame);
}
void FrameLoader::loadHistoryItem(HistoryItem* item, HistoryLoadType historyLoadType, ResourceRequestCachePolicy cachePolicy)
{
+ RefPtrWillBeRawPtr<LocalFrame> protect(m_frame.get());
if (m_frame->page()->defersLoading()) {
m_deferredHistoryLoad = DeferredHistoryLoad(item, historyLoadType, cachePolicy);
return;
m_provisionalItem = item;
if (historyLoadType == HistorySameDocumentLoad) {
- m_loadType = FrameLoadTypeBackForward;
- loadInSameDocument(item->url(), item->stateObject(), DoNotUpdateBackForwardList, NotClientRedirect);
+ loadInSameDocument(item->url(), item->stateObject(), FrameLoadTypeBackForward, NotClientRedirect);
restoreScrollPositionAndViewState();
return;
}
- loadWithNavigationAction(NavigationAction(requestFromHistoryItem(item, cachePolicy), FrameLoadTypeBackForward), FrameLoadTypeBackForward, nullptr, SubstituteData());
+
+ ResourceRequest request = requestFromHistoryItem(item, cachePolicy);
+ request.setFrameType(m_frame->isMainFrame() ? WebURLRequest::FrameTypeTopLevel : WebURLRequest::FrameTypeNested);
+ request.setRequestContext(WebURLRequest::RequestContextInternal);
+ loadWithNavigationAction(NavigationAction(request, FrameLoadTypeBackForward), FrameLoadTypeBackForward, nullptr, SubstituteData(), CheckContentSecurityPolicy);
}
void FrameLoader::dispatchDocumentElementAvailable()
{
- m_client->documentElementAvailable();
+ client()->documentElementAvailable();
}
-void FrameLoader::dispatchDidClearWindowObjectsInAllWorlds()
+void FrameLoader::dispatchDidClearDocumentOfWindowObject()
{
if (!m_frame->script().canExecuteScripts(NotAboutToExecuteScript))
return;
if (Page* page = m_frame->page())
- page->inspectorController().didClearWindowObjectInMainWorld(m_frame);
- InspectorInstrumentation::didClearWindowObjectInMainWorld(m_frame);
+ page->inspectorController().didClearDocumentOfWindowObject(m_frame);
+ InspectorInstrumentation::didClearDocumentOfWindowObject(m_frame);
- Vector<RefPtr<DOMWrapperWorld> > worlds;
- DOMWrapperWorld::allWorldsInMainThread(worlds);
- for (size_t i = 0; i < worlds.size(); ++i)
- m_client->dispatchDidClearWindowObjectInWorld(worlds[i].get());
+ // We just cleared the document, not the entire window object, but for the
+ // embedder that's close enough.
+ client()->dispatchDidClearWindowObjectInMainWorld();
}
-void FrameLoader::dispatchDidClearWindowObjectInWorld(DOMWrapperWorld* world)
+void FrameLoader::dispatchDidClearWindowObjectInMainWorld()
{
- if (!m_frame->script().canExecuteScripts(NotAboutToExecuteScript) || !m_frame->script().existingWindowShell(world))
+ if (!m_frame->script().canExecuteScripts(NotAboutToExecuteScript))
return;
- m_client->dispatchDidClearWindowObjectInWorld(world);
+ client()->dispatchDidClearWindowObjectInMainWorld();
}
SandboxFlags FrameLoader::effectiveSandboxFlags() const
{
SandboxFlags flags = m_forcedSandboxFlags;
- if (LocalFrame* parentFrame = m_frame->tree().parent())
- flags |= parentFrame->document()->sandboxFlags();
- if (HTMLFrameOwnerElement* ownerElement = m_frame->ownerElement())
- flags |= ownerElement->sandboxFlags();
+ // FIXME: We need a way to propagate sandbox flags to out-of-process frames.
+ Frame* parentFrame = m_frame->tree().parent();
+ if (parentFrame && parentFrame->isLocalFrame())
+ flags |= toLocalFrame(parentFrame)->document()->sandboxFlags();
+ if (FrameOwner* frameOwner = m_frame->owner())
+ flags |= frameOwner->sandboxFlags();
return flags;
}
-} // namespace WebCore
+} // namespace blink
projects / platform / framework / web / crosswalk.git / blobdiff