Rename LockBackForwardList to ReplaceCurrentItem.

Source/core/loader/NavigationScheduler.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 50 matching lines @@
 }
 
 FrameNavigationDisabler::~FrameNavigationDisabler()
 {
     m_navigationScheduler.enableFrameNavigation();
 }
 
 class ScheduledNavigation : public NoBaseWillBeGarbageCollectedFinalized<ScheduledNavigation> {
     WTF_MAKE_NONCOPYABLE(ScheduledNavigation); WTF_MAKE_FAST_ALLOCATED_WILL_BE_REMOVED(ScheduledNavigation);
 public:
-    ScheduledNavigation(double delay, Document* originDocument, bool lockBackForwardList, bool isLocationChange)
+    ScheduledNavigation(double delay, Document* originDocument, bool replacesCurrentItem, bool isLocationChange)
         : m_delay(delay)
         , m_originDocument(originDocument)
-        , m_lockBackForwardList(lockBackForwardList)
+        , m_replacesCurrentItem(replacesCurrentItem)

[Charlie Reis, 2015/07/10 22:51:14]

Same here.

         , m_isLocationChange(isLocationChange)
         , m_wasUserGesture(UserGestureIndicator::processingUserGesture())
     {
         if (m_wasUserGesture)
             m_userGestureToken = UserGestureIndicator::currentToken();
     }
     virtual ~ScheduledNavigation() { }
 
     virtual void fire(LocalFrame*) = 0;
 
     virtual bool shouldStartTimer(LocalFrame*) { return true; }
 
     double delay() const { return m_delay; }
     Document* originDocument() const { return m_originDocument.get(); }
-    bool lockBackForwardList() const { return m_lockBackForwardList; }
+    bool replacesCurrentItem() const { return m_replacesCurrentItem; }
     bool isLocationChange() const { return m_isLocationChange; }
     PassOwnPtr<UserGestureIndicator> createUserGestureIndicator()
     {
         if (m_wasUserGesture &&  m_userGestureToken)
             return adoptPtr(new UserGestureIndicator(m_userGestureToken));
         return adoptPtr(new UserGestureIndicator(DefinitelyNotProcessingUserGesture));
     }
 
     DEFINE_INLINE_VIRTUAL_TRACE()
     {
         visitor->trace(m_originDocument);
     }
 
 protected:
     void clearUserGesture() { m_wasUserGesture = false; }
 
 private:
     double m_delay;
     RefPtrWillBeMember<Document> m_originDocument;
-    bool m_lockBackForwardList;
+    bool m_replacesCurrentItem;
     bool m_isLocationChange;
     bool m_wasUserGesture;
     RefPtr<UserGestureToken> m_userGestureToken;
 };
 
 class ScheduledURLNavigation : public ScheduledNavigation {
 protected:
-    ScheduledURLNavigation(double delay, Document* originDocument, const String& url, bool lockBackForwardList, bool isLocationChange)
-        : ScheduledNavigation(delay, originDocument, lockBackForwardList, isLocationChange)
+    ScheduledURLNavigation(double delay, Document* originDocument, const String& url, bool replacesCurrentItem, bool isLocationChange)
+        : ScheduledNavigation(delay, originDocument, replacesCurrentItem, isLocationChange)
         , m_url(url)
         , m_shouldCheckMainWorldContentSecurityPolicy(CheckContentSecurityPolicy)
     {
         if (ContentSecurityPolicy::shouldBypassMainWorld(originDocument))
             m_shouldCheckMainWorldContentSecurityPolicy = DoNotCheckContentSecurityPolicy;
     }
 
     void fire(LocalFrame* frame) override
     {
         OwnPtr<UserGestureIndicator> gestureIndicator = createUserGestureIndicator();
         FrameLoadRequest request(originDocument(), m_url, "_self", m_shouldCheckMainWorldContentSecurityPolicy);
-        request.setLockBackForwardList(lockBackForwardList());
+        request.setReplacesCurrentItem(replacesCurrentItem());
         request.setClientRedirect(ClientRedirect);
         frame->loader().load(request);
     }
 
     String url() const { return m_url; }
 
 private:
     String m_url;
     ContentSecurityPolicyDisposition m_shouldCheckMainWorldContentSecurityPolicy;
 };
 
 class ScheduledRedirect final : public ScheduledURLNavigation {
 public:
-    static PassOwnPtrWillBeRawPtr<ScheduledRedirect> create(double delay, Document* originDocument, const String& url, bool lockBackForwardList)
+    static PassOwnPtrWillBeRawPtr<ScheduledRedirect> create(double delay, Document* originDocument, const String& url, bool replacesCurrentItem)
     {
-        return adoptPtrWillBeNoop(new ScheduledRedirect(delay, originDocument, url, lockBackForwardList));
+        return adoptPtrWillBeNoop(new ScheduledRedirect(delay, originDocument, url, replacesCurrentItem));
     }
 
     bool shouldStartTimer(LocalFrame* frame) override { return frame->document()->loadEventFinished(); }
 
     void fire(LocalFrame* frame) override
     {
         OwnPtr<UserGestureIndicator> gestureIndicator = createUserGestureIndicator();
         FrameLoadRequest request(originDocument(), url(), "_self");
-        request.setLockBackForwardList(lockBackForwardList());
+        request.setReplacesCurrentItem(replacesCurrentItem());
         if (equalIgnoringFragmentIdentifier(frame->document()->url(), request.resourceRequest().url()))
             request.resourceRequest().setCachePolicy(ReloadIgnoringCacheData);
         request.setClientRedirect(ClientRedirect);
         frame->loader().load(request);
     }
 private:
-    ScheduledRedirect(double delay, Document* originDocument, const String& url, bool lockBackForwardList)
-        : ScheduledURLNavigation(delay, originDocument, url, lockBackForwardList, false)
+    ScheduledRedirect(double delay, Document* originDocument, const String& url, bool replacesCurrentItem)
+        : ScheduledURLNavigation(delay, originDocument, url, replacesCurrentItem, false)
     {
         clearUserGesture();
     }
 };
 
 class ScheduledLocationChange final : public ScheduledURLNavigation {
 public:
-    static PassOwnPtrWillBeRawPtr<ScheduledLocationChange> create(Document* originDocument, const String& url, bool lockBackForwardList)
+    static PassOwnPtrWillBeRawPtr<ScheduledLocationChange> create(Document* originDocument, const String& url, bool replacesCurrentItem)
     {
-        return adoptPtrWillBeNoop(new ScheduledLocationChange(originDocument, url, lockBackForwardList));
+        return adoptPtrWillBeNoop(new ScheduledLocationChange(originDocument, url, replacesCurrentItem));
     }
 
 private:
-    ScheduledLocationChange(Document* originDocument, const String& url, bool lockBackForwardList)
-        : ScheduledURLNavigation(0.0, originDocument, url, lockBackForwardList, !protocolIsJavaScript(url)) { }
+    ScheduledLocationChange(Document* originDocument, const String& url, bool replacesCurrentItem)
+        : ScheduledURLNavigation(0.0, originDocument, url, replacesCurrentItem, !protocolIsJavaScript(url)) { }
 };
 
 class ScheduledReload final : public ScheduledNavigation {
 public:
     static PassOwnPtrWillBeRawPtr<ScheduledReload> create()
     {
         return adoptPtrWillBeNoop(new ScheduledReload);
     }
 
     void fire(LocalFrame* frame) override
@@ skipping 20 matching lines @@
     static PassOwnPtrWillBeRawPtr<ScheduledPageBlock> create(Document* originDocument, const String& url)
     {
         return adoptPtrWillBeNoop(new ScheduledPageBlock(originDocument, url));
     }
 
     void fire(LocalFrame* frame) override
     {
         OwnPtr<UserGestureIndicator> gestureIndicator = createUserGestureIndicator();
         SubstituteData substituteData(SharedBuffer::create(), "text/plain", "UTF-8", KURL(), ForceSynchronousLoad);
         FrameLoadRequest request(originDocument(), url(), substituteData);
-        request.setLockBackForwardList(true);
+        request.setReplacesCurrentItem(true);
         request.setClientRedirect(ClientRedirect);
         frame->loader().load(request);
     }
 private:
     ScheduledPageBlock(Document* originDocument, const String& url)
         : ScheduledURLNavigation(0.0, originDocument, url, true, true)
     {
     }
 
 };
 
 class ScheduledFormSubmission final : public ScheduledNavigation {
 public:
-    static PassOwnPtrWillBeRawPtr<ScheduledFormSubmission> create(Document* document, PassRefPtrWillBeRawPtr<FormSubmission> submission, bool lockBackForwardList)
+    static PassOwnPtrWillBeRawPtr<ScheduledFormSubmission> create(Document* document, PassRefPtrWillBeRawPtr<FormSubmission> submission, bool replacesCurrentItem)
     {
-        return adoptPtrWillBeNoop(new ScheduledFormSubmission(document, submission, lockBackForwardList));
+        return adoptPtrWillBeNoop(new ScheduledFormSubmission(document, submission, replacesCurrentItem));
     }
 
     void fire(LocalFrame* frame) override
     {
         OwnPtr<UserGestureIndicator> gestureIndicator = createUserGestureIndicator();
         FrameLoadRequest frameRequest(originDocument());
         m_submission->populateFrameLoadRequest(frameRequest);
-        frameRequest.setLockBackForwardList(lockBackForwardList());
+        frameRequest.setReplacesCurrentItem(replacesCurrentItem());
         frameRequest.setTriggeringEvent(m_submission->event());
         frameRequest.setForm(m_submission->form());
         frame->loader().load(frameRequest);
     }
 
     DEFINE_INLINE_VIRTUAL_TRACE()
     {
         visitor->trace(m_submission);
         ScheduledNavigation::trace(visitor);
     }
 
 private:
-    ScheduledFormSubmission(Document* document, PassRefPtrWillBeRawPtr<FormSubmission> submission, bool lockBackForwardList)
-        : ScheduledNavigation(0, document, lockBackForwardList, true)
+    ScheduledFormSubmission(Document* document, PassRefPtrWillBeRawPtr<FormSubmission> submission, bool replacesCurrentItem)
+        : ScheduledNavigation(0, document, replacesCurrentItem, true)
         , m_submission(submission)
     {
         ASSERT(m_submission->form());
     }
 
     RefPtrWillBeMember<FormSubmission> m_submission;
 };
 
 NavigationScheduler::NavigationScheduler(LocalFrame* frame)
     : m_frame(frame)
@@ skipping 28 matching lines @@
     if (delay < 0 || delay > INT_MAX / 1000)
         return;
     if (url.isEmpty())
         return;
 
     // We want a new back/forward list item if the refresh timeout is > 1 second.
     if (!m_redirect || delay <= m_redirect->delay())
         schedule(ScheduledRedirect::create(delay, m_frame->document(), url, delay <= 1));
 }
 
-bool NavigationScheduler::mustLockBackForwardList(LocalFrame* targetFrame)
+bool NavigationScheduler::mustReplaceCurrentItem(LocalFrame* targetFrame)
 {
     // Non-user navigation before the page has finished firing onload should not create a new back/forward item.
     // See https://webkit.org/b/42861 for the original motivation for this.
     if (!UserGestureIndicator::processingUserGesture() && !targetFrame->document()->loadEventFinished())
         return true;
 
     // Navigation of a subframe during loading of an ancestor frame does not create a new back/forward item.
     // The definition of "during load" is any time before all handlers for the load event have been run.
     // See https://bugs.webkit.org/show_bug.cgi?id=14957 for the original motivation for this.
     Frame* parentFrame = targetFrame->tree().parent();
     return parentFrame && parentFrame->isLocalFrame() && !toLocalFrame(parentFrame)->loader().allAncestorsAreComplete();
 }
 
-void NavigationScheduler::scheduleLocationChange(Document* originDocument, const String& url, bool lockBackForwardList)
+void NavigationScheduler::scheduleLocationChange(Document* originDocument, const String& url, bool replacesCurrentItem)
 {
     if (!shouldScheduleNavigation(url))
         return;
     if (url.isEmpty())
         return;
 
-    lockBackForwardList = lockBackForwardList || mustLockBackForwardList(m_frame);
+    replacesCurrentItem = replacesCurrentItem || mustReplaceCurrentItem(m_frame);
 
     // If the URL we're going to navigate to is the same as the current one, except for the
     // fragment part, we don't need to schedule the location change. We'll skip this
     // optimization for cross-origin navigations to minimize the navigator's ability to
     // execute timing attacks.
     if (originDocument->securityOrigin()->canAccess(m_frame->document()->securityOrigin())) {
         KURL parsedURL(ParsedURLString, url);
         if (parsedURL.hasFragmentIdentifier() && equalIgnoringFragmentIdentifier(m_frame->document()->url(), parsedURL)) {
             FrameLoadRequest request(originDocument, m_frame->document()->completeURL(url), "_self");
-            request.setLockBackForwardList(lockBackForwardList);
-            if (lockBackForwardList)
+            request.setReplacesCurrentItem(replacesCurrentItem);
+            if (replacesCurrentItem)
                 request.setClientRedirect(ClientRedirect);
             m_frame->loader().load(request);
             return;
         }
     }
 
-    schedule(ScheduledLocationChange::create(originDocument, url, lockBackForwardList));
+    schedule(ScheduledLocationChange::create(originDocument, url, replacesCurrentItem));
 }
 
 void NavigationScheduler::schedulePageBlock(Document* originDocument)
 {
     ASSERT(m_frame->page());
     const KURL& url = m_frame->document()->url();
     schedule(ScheduledPageBlock::create(originDocument, url));
 }
 
 void NavigationScheduler::scheduleFormSubmission(Document* document, PassRefPtrWillBeRawPtr<FormSubmission> submission)
 {
     ASSERT(m_frame->page());
-    schedule(ScheduledFormSubmission::create(document, submission, mustLockBackForwardList(m_frame)));
+    schedule(ScheduledFormSubmission::create(document, submission, mustReplaceCurrentItem(m_frame)));
 }
 
 void NavigationScheduler::scheduleReload()
 {
     if (!shouldScheduleReload())
         return;
     if (m_frame->document()->url().isEmpty())
         return;
     schedule(ScheduledReload::create());
 }
@@ skipping 57 matching lines @@
     m_redirect.clear();
 }
 
 DEFINE_TRACE(NavigationScheduler)
 {
     visitor->trace(m_frame);
     visitor->trace(m_redirect);
 }
 
 } // namespace blink