#include "config.h"
#include "core/loader/NavigationScheduler.h"
-#include "bindings/v8/ScriptController.h"
+#include "bindings/core/v8/ScriptController.h"
#include "core/events/Event.h"
+#include "core/fetch/ResourceLoaderOptions.h"
#include "core/frame/LocalFrame.h"
+#include "core/frame/csp/ContentSecurityPolicy.h"
#include "core/html/HTMLFormElement.h"
#include "core/inspector/InspectorInstrumentation.h"
#include "core/loader/DocumentLoader.h"
#include "core/loader/FrameLoaderStateMachine.h"
#include "core/page/BackForwardClient.h"
#include "core/page/Page.h"
+#include "platform/SharedBuffer.h"
#include "platform/UserGestureIndicator.h"
#include "wtf/CurrentTime.h"
-namespace WebCore {
+namespace blink {
unsigned NavigationDisablerForBeforeUnload::s_navigationDisableCount = 0;
return adoptPtr(new UserGestureIndicator(DefinitelyNotProcessingUserGesture));
}
- virtual bool isForm() const { return false; }
-
protected:
void clearUserGesture() { m_wasUserGesture = false; }
, m_originDocument(originDocument)
, m_url(url)
, m_referrer(referrer)
+ , m_shouldCheckMainWorldContentSecurityPolicy(CheckContentSecurityPolicy)
{
+ if (ContentSecurityPolicy::shouldBypassMainWorld(originDocument))
+ m_shouldCheckMainWorldContentSecurityPolicy = DoNotCheckContentSecurityPolicy;
}
virtual void fire(LocalFrame* frame) OVERRIDE
{
OwnPtr<UserGestureIndicator> gestureIndicator = createUserGestureIndicator();
- FrameLoadRequest request(m_originDocument.get(), ResourceRequest(KURL(ParsedURLString, m_url), m_referrer), "_self");
+ FrameLoadRequest request(m_originDocument.get(), ResourceRequest(KURL(ParsedURLString, m_url), m_referrer), "_self", m_shouldCheckMainWorldContentSecurityPolicy);
request.setLockBackForwardList(lockBackForwardList());
request.setClientRedirect(ClientRedirect);
frame->loader().load(request);
RefPtrWillBePersistent<Document> m_originDocument;
String m_url;
Referrer m_referrer;
+ ContentSecurityPolicyCheck m_shouldCheckMainWorldContentSecurityPolicy;
};
class ScheduledRedirect FINAL : public ScheduledURLNavigation {
: ScheduledURLNavigation(0.0, originDocument, url, referrer, lockBackForwardList, true) { }
};
-class ScheduledRefresh FINAL : public ScheduledURLNavigation {
+class ScheduledReload FINAL : public ScheduledNavigation {
public:
- ScheduledRefresh(Document* originDocument, const String& url, const Referrer& referrer)
+ ScheduledReload()
+ : ScheduledNavigation(0.0, true, true)
+ {
+ }
+
+ virtual void fire(LocalFrame* frame) OVERRIDE
+ {
+ OwnPtr<UserGestureIndicator> gestureIndicator = createUserGestureIndicator();
+ frame->loader().reload(NormalReload, KURL(), nullAtom, ClientRedirect);
+ }
+};
+
+class ScheduledPageBlock FINAL : public ScheduledURLNavigation {
+public:
+ ScheduledPageBlock(Document* originDocument, const String& url, const Referrer& referrer)
: ScheduledURLNavigation(0.0, originDocument, url, referrer, true, true)
{
}
virtual void fire(LocalFrame* frame) OVERRIDE
{
OwnPtr<UserGestureIndicator> gestureIndicator = createUserGestureIndicator();
- FrameLoadRequest request(originDocument(), ResourceRequest(KURL(ParsedURLString, url()), referrer(), ReloadIgnoringCacheData), "_self");
- request.setLockBackForwardList(lockBackForwardList());
+ SubstituteData substituteData(SharedBuffer::create(), "text/plain", "UTF-8", KURL(), ForceSynchronousLoad);
+ FrameLoadRequest request(originDocument(), ResourceRequest(KURL(ParsedURLString, url()), referrer(), ReloadIgnoringCacheData), substituteData);
+ request.setLockBackForwardList(true);
request.setClientRedirect(ClientRedirect);
frame->loader().load(request);
}
virtual void fire(LocalFrame* frame) OVERRIDE
{
OwnPtr<UserGestureIndicator> gestureIndicator = createUserGestureIndicator();
-
- if (!m_historySteps) {
- FrameLoadRequest frameRequest(frame->document(), ResourceRequest(frame->document()->url()));
- frameRequest.setLockBackForwardList(lockBackForwardList());
- // Special case for go(0) from a frame -> reload only the frame
- // To follow Firefox and IE's behavior, history reload can only navigate the self frame.
- frame->loader().load(frameRequest);
- return;
- }
// go(i!=0) from a frame navigates into the history of the frame only,
// in both IE and NS (but not in Mozilla). We can't easily do that.
frame->page()->deprecatedLocalMainFrame()->loader().client()->navigateBackForward(m_historySteps);
frame->loader().load(frameRequest);
}
- virtual bool isForm() const OVERRIDE { return true; }
- FormSubmission* submission() const { return m_submission.get(); }
-
private:
RefPtrWillBePersistent<FormSubmission> m_submission;
};
return m_redirect && m_redirect->isLocationChange();
}
-void NavigationScheduler::clear()
-{
- if (m_timer.isActive())
- InspectorInstrumentation::frameClearedScheduledNavigation(m_frame);
- m_timer.stop();
- m_redirect.clear();
-}
-
inline bool NavigationScheduler::shouldScheduleNavigation() const
{
return m_frame->page();
schedule(adoptPtr(new ScheduledLocationChange(originDocument, url, referrer, lockBackForwardList)));
}
+void NavigationScheduler::schedulePageBlock(Document* originDocument, const Referrer& referrer)
+{
+ ASSERT(m_frame->page());
+ const KURL& url = m_frame->document()->url();
+ schedule(adoptPtr(new ScheduledPageBlock(originDocument, url, referrer)));
+}
+
void NavigationScheduler::scheduleFormSubmission(PassRefPtrWillBeRawPtr<FormSubmission> submission)
{
ASSERT(m_frame->page());
schedule(adoptPtr(new ScheduledFormSubmission(submission, mustLockBackForwardList(m_frame))));
}
-void NavigationScheduler::scheduleRefresh()
+void NavigationScheduler::scheduleReload()
{
if (!shouldScheduleNavigation())
return;
- const KURL& url = m_frame->document()->url();
- if (url.isEmpty())
+ if (m_frame->document()->url().isEmpty())
return;
-
- schedule(adoptPtr(new ScheduledRefresh(m_frame->document(), url.string(), Referrer(m_frame->document()->outgoingReferrer(), m_frame->document()->referrerPolicy()))));
+ schedule(adoptPtr(new ScheduledReload));
}
void NavigationScheduler::scheduleHistoryNavigation(int steps)
}
// In all other cases, schedule the history traversal to occur asynchronously.
- schedule(adoptPtr(new ScheduledHistoryNavigation(steps)));
+ if (steps)
+ schedule(adoptPtr(new ScheduledHistoryNavigation(steps)));
+ else
+ schedule(adoptPtr(new ScheduledReload));
}
void NavigationScheduler::timerFired(Timer<NavigationScheduler>*)
return;
}
- RefPtr<LocalFrame> protect(m_frame);
+ RefPtrWillBeRawPtr<LocalFrame> protect(m_frame.get());
OwnPtr<ScheduledNavigation> redirect(m_redirect.release());
redirect->fire(m_frame);
// and/or confuse the JS when it shortly thereafter tries to schedule a location change. Let the JS have its way.
// FIXME: This check seems out of place.
if (!m_frame->loader().stateMachine()->committedFirstRealDocumentLoad() && m_frame->loader().provisionalDocumentLoader()) {
- RefPtr<Frame> protect(m_frame);
+ RefPtrWillBeRawPtr<LocalFrame> protect(m_frame.get());
m_frame->loader().provisionalDocumentLoader()->stopLoading();
if (!m_frame->host())
return;
m_redirect.clear();
}
-} // namespace WebCore
+void NavigationScheduler::trace(Visitor* visitor)
+{
+ visitor->trace(m_frame);
+}
+
+} // namespace blink
projects / platform / framework / web / crosswalk.git / blobdiff