Merge 67716

WebCore/loader/RedirectScheduler.cpp

 /*
  * Copyright (C) 2006, 2007, 2008, 2009, 2010 Apple Inc. All rights reserved.
  * Copyright (C) 2008 Nokia Corporation and/or its subsidiary(-ies)
  * Copyright (C) 2008, 2009 Torch Mobile Inc. All rights reserved. (http://www.torchmobile.com/)
  * Copyright (C) 2009 Adam Barth. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  *
@@ skipping 15 matching lines @@
  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #include "config.h"
 #include "RedirectScheduler.h"
 
 #include "BackForwardList.h"
+#include "DOMWindow.h"
 #include "DocumentLoader.h"
 #include "Event.h"
 #include "FormState.h"
 #include "FormSubmission.h"
 #include "Frame.h"
 #include "FrameLoadRequest.h"
 #include "FrameLoader.h"
 #include "FrameLoaderStateMachine.h"
-#include "HistoryItem.h"
 #include "HTMLFormElement.h"
 #include "HTMLFrameOwnerElement.h"
+#include "HistoryItem.h"
 #include "Page.h"
 #include "UserGestureIndicator.h"
 #include <wtf/CurrentTime.h>
 
 namespace WebCore {
 
 class ScheduledNavigation : public Noncopyable {
 public:
-    ScheduledNavigation(double delay, bool lockHistory, bool lockBackForwardList, bool wasDuringLoad, bool isLocationChange)
+    ScheduledNavigation(double delay, bool lockHistory, bool lockBackForwardList, bool wasDuringLoad, bool isLocationChange, bool wasUserGesture)
         : m_delay(delay)
         , m_lockHistory(lockHistory)
         , m_lockBackForwardList(lockBackForwardList)
         , m_wasDuringLoad(wasDuringLoad)
         , m_isLocationChange(isLocationChange)
+        , m_wasUserGesture(wasUserGesture)
     {
     }
     virtual ~ScheduledNavigation() { }
 
     virtual void fire(Frame*) = 0;
 
     virtual bool shouldStartTimer(Frame*) { return true; }
     virtual void didStartTimer(Frame*, Timer<RedirectScheduler>*) { }
     virtual void didStopTimer(Frame*, bool /* newLoadInProgress */) { }
 
     double delay() const { return m_delay; }
     bool lockHistory() const { return m_lockHistory; }
     bool lockBackForwardList() const { return m_lockBackForwardList; }
     bool wasDuringLoad() const { return m_wasDuringLoad; }
     bool isLocationChange() const { return m_isLocationChange; }
+    bool wasUserGesture() const { return m_wasUserGesture; }
 
 private:
     double m_delay;
     bool m_lockHistory;
     bool m_lockBackForwardList;
     bool m_wasDuringLoad;
     bool m_isLocationChange;
+    bool m_wasUserGesture;
 };
 
 class ScheduledURLNavigation : public ScheduledNavigation {
 public:
     ScheduledURLNavigation(double delay, const String& url, const String& referrer, bool lockHistory, bool lockBackForwardList, bool wasUserGesture, bool duringLoad, bool isLocationChange)
-        : ScheduledNavigation(delay, lockHistory, lockBackForwardList, duringLoad, isLocationChange)
+        : ScheduledNavigation(delay, lockHistory, lockBackForwardList, duringLoad, isLocationChange, wasUserGesture)
         , m_url(url)
         , m_referrer(referrer)
-        , m_wasUserGesture(wasUserGesture)
         , m_haveToldClient(false)
     {
     }
 
     virtual void fire(Frame* frame)
     {
-        frame->loader()->changeLocation(KURL(ParsedURLString, m_url), m_referrer, lockHistory(), lockBackForwardList(), m_wasUserGesture, false);
+        frame->loader()->changeLocation(KURL(ParsedURLString, m_url), m_referrer, lockHistory(), lockBackForwardList(), wasUserGesture(), false);
     }
 
     virtual void didStartTimer(Frame* frame, Timer<RedirectScheduler>* timer)
     {
         if (m_haveToldClient)
             return;
         m_haveToldClient = true;
         frame->loader()->clientRedirected(KURL(ParsedURLString, m_url), delay(), currentTime() + timer->nextFireInterval(), lockBackForwardList());
     }
 
     virtual void didStopTimer(Frame* frame, bool newLoadInProgress)
     {
         if (!m_haveToldClient)
             return;
         frame->loader()->clientRedirectCancelledOrFinished(newLoadInProgress);
     }
 
     String url() const { return m_url; }
     String referrer() const { return m_referrer; }
-    bool wasUserGesture() const { return m_wasUserGesture; }
 
 private:
     String m_url;
     String m_referrer;
-    bool m_wasUserGesture;
     bool m_haveToldClient;
 };
 
 class ScheduledRedirect : public ScheduledURLNavigation {
 public:
     ScheduledRedirect(double delay, const String& url, bool lockHistory, bool lockBackForwardList, bool wasUserGesture)
         : ScheduledURLNavigation(delay, url, String(), lockHistory, lockBackForwardList, wasUserGesture, false, false) { }
 
     virtual bool shouldStartTimer(Frame* frame) { return frame->loader()->allAncestorsAreComplete(); }
 };
@@ skipping 10 matching lines @@
         : ScheduledURLNavigation(0.0, url, referrer, true, true, wasUserGesture, false, true) { }
 
     virtual void fire(Frame* frame)
     {
         frame->loader()->changeLocation(KURL(ParsedURLString, url()), referrer(), lockHistory(), lockBackForwardList(), wasUserGesture(), true);
     }
 };
 
 class ScheduledHistoryNavigation : public ScheduledNavigation {
 public:
-    explicit ScheduledHistoryNavigation(int historySteps) : ScheduledNavigation(0, false, false, false, true), m_historySteps(historySteps) { }
+    explicit ScheduledHistoryNavigation(int historySteps, bool wasUserGesture) : ScheduledNavigation(0, false, false, false, true, wasUserGesture), m_historySteps(historySteps) { }
 
     virtual void fire(Frame* frame)
     {
+        UserGestureIndicator gestureIndicator(wasUserGesture() ? DefinitelyProcessingUserGesture : DefinitelyNotProcessingUserGesture);
+
         FrameLoader* loader = frame->loader();
         if (!m_historySteps) {
             // Special case for go(0) from a frame -> reload only the frame
-            loader->urlSelected(loader->url(), "", 0, lockHistory(), lockBackForwardList(), false, SendReferrer);
+            // To follow Firefox and IE's behavior, history reload can only navigate the self frame.
+            loader->urlSelected(loader->url(), "_self", 0, lockHistory(), lockBackForwardList(), wasUserGesture(), SendReferrer);
             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()->goBackOrForward(m_historySteps);
     }
 
 private:
     int m_historySteps;
 };
 
 class ScheduledFormSubmission : public ScheduledNavigation {
 public:
     ScheduledFormSubmission(PassRefPtr<FormSubmission> submission, bool lockBackForwardList, bool duringLoad, bool wasUserGesture)
-        : ScheduledNavigation(0, submission->lockHistory(), lockBackForwardList, duringLoad, true)
+        : ScheduledNavigation(0, submission->lockHistory(), lockBackForwardList, duringLoad, true, wasUserGesture)
         , m_submission(submission)
         , m_haveToldClient(false)
-        , m_wasUserGesture(wasUserGesture)
     {
         ASSERT(m_submission->state());
     }
 
     virtual void fire(Frame* frame)
     {
-        UserGestureIndicator gestureIndicator(m_wasUserGesture ? DefinitelyProcessingUserGesture : DefinitelyNotProcessingUserGesture);
+        UserGestureIndicator gestureIndicator(wasUserGesture() ? DefinitelyProcessingUserGesture : DefinitelyNotProcessingUserGesture);
 
         // The submitForm function will find a target frame before using the redirection timer.
         // Now that the timer has fired, we need to repeat the security check which normally is done when
         // selecting a target, in case conditions have changed. Other code paths avoid this by targeting
         // without leaving a time window. If we fail the check just silently drop the form submission.
         if (!m_submission->state()->sourceFrame()->loader()->shouldAllowNavigation(frame))
             return;
         FrameLoadRequest frameRequest;
         m_submission->populateFrameLoadRequest(frameRequest);
         frame->loader()->loadFrameRequest(frameRequest, lockHistory(), lockBackForwardList(), m_submission->event(), m_submission->state(), SendReferrer);
@@ skipping 10 matching lines @@
     virtual void didStopTimer(Frame* frame, bool newLoadInProgress)
     {
         if (!m_haveToldClient)
             return;
         frame->loader()->clientRedirectCancelledOrFinished(newLoadInProgress);
     }
 
 private:
     RefPtr<FormSubmission> m_submission;
     bool m_haveToldClient;
-    bool m_wasUserGesture;
 };
 
 RedirectScheduler::RedirectScheduler(Frame* frame)
     : m_frame(frame)
     , m_timer(this, &RedirectScheduler::timerFired)
 {
 }
 
 RedirectScheduler::~RedirectScheduler()
 {
@@ skipping 109 matching lines @@
     if (!m_frame->page())
         return;
 
     // Invalid history navigations (such as history.forward() during a new load) have the side effect of cancelling any scheduled
     // redirects. We also avoid the possibility of cancelling the current load by avoiding the scheduled redirection altogether.
     HistoryItem* specifiedEntry = m_frame->page()->backForwardList()->itemAtIndex(steps);
     if (!specifiedEntry) {
         cancel();
         return;
     }
-    
+
     // In all other cases, schedule the history traversal to occur asynchronously.
-    schedule(adoptPtr(new ScheduledHistoryNavigation(steps)));
+    schedule(adoptPtr(new ScheduledHistoryNavigation(steps, m_frame->loader()->isProcessingUserGesture())));
 }
 
 void RedirectScheduler::timerFired(Timer<RedirectScheduler>*)
 {
     if (!m_frame->page())
         return;
     if (m_frame->page()->defersLoading())
         return;
 
     OwnPtr<ScheduledNavigation> redirect(m_redirect.release());
@@ skipping 40 matching lines @@
 void RedirectScheduler::cancel(bool newLoadInProgress)
 {
     m_timer.stop();
 
     OwnPtr<ScheduledNavigation> redirect(m_redirect.release());
     if (redirect)
         redirect->didStopTimer(m_frame, newLoadInProgress);
 }
 
 } // namespace WebCore