Source/WebCore/loader/HistoryController.cpp

   1 /*
   2  * Copyright (C) 2006, 2007, 2008, 2009 Apple Inc. All rights reserved.
   3  * Copyright (C) 2008 Nokia Corporation and/or its subsidiary(-ies)
   4  * Copyright (C) 2008, 2009 Torch Mobile Inc. All rights reserved. (http://www.torchmobile.com/)
   5  *
   6  * Redistribution and use in source and binary forms, with or without
   7  * modification, are permitted provided that the following conditions
   8  * are met:
   9  *
  10  * 1.  Redistributions of source code must retain the above copyright
  11  *     notice, this list of conditions and the following disclaimer.
  12  * 2.  Redistributions in binary form must reproduce the above copyright
  13  *     notice, this list of conditions and the following disclaimer in the
  14  *     documentation and/or other materials provided with the distribution.
  15  * 3.  Neither the name of Apple Inc. ("Apple") nor the names of
  16  *     its contributors may be used to endorse or promote products derived
  17  *     from this software without specific prior written permission.
  18  *
  19  * THIS SOFTWARE IS PROVIDED BY APPLE AND ITS CONTRIBUTORS "AS IS" AND ANY
  20  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  21  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  22  * DISCLAIMED. IN NO EVENT SHALL APPLE OR ITS CONTRIBUTORS BE LIABLE FOR ANY
  23  * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  24  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  25  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  26  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  27  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  28  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  29  */
  30
  31 #include "config.h"
  32 #include "HistoryController.h"
  33
  34 #include "BackForwardController.h"
  35 #include "CachedPage.h"
  36 #include "Document.h"
  37 #include "DocumentLoader.h"
  38 #include "FrameLoader.h"
  39 #include "FrameLoaderClient.h"
  40 #include "FrameLoaderStateMachine.h"
  41 #include "FrameTree.h"
  42 #include "FrameView.h"
  43 #include "HistoryItem.h"
  44 #include "LinkHash.h"
  45 #include "Logging.h"
  46 #include "MainFrame.h"
  47 #include "Page.h"
  48 #include "PageCache.h"
  49 #include "PageGroup.h"
  50 #include "ScrollingCoordinator.h"
  51 #include "VisitedLinkStore.h"
  52 #include <wtf/text/CString.h>
  53
  54 namespace WebCore {
  55
  56 static inline void addVisitedLink(Page& page, const URL& url)
  57 {
  58     page.visitedLinkStore().addVisitedLink(page, visitedLinkHash(url.string()));
  59 }
  60
  61 HistoryController::HistoryController(Frame& frame)
  62     : m_frame(frame)
  63     , m_frameLoadComplete(true)
  64     , m_defersLoading(false)
  65 {
  66 }
  67
  68 HistoryController::~HistoryController()
  69 {
  70 }
  71
  72 void HistoryController::saveScrollPositionAndViewStateToItem(HistoryItem* item)
  73 {
  74     FrameView* frameView = m_frame.view();
  75     if (!item || !frameView)
  76         return;
  77
  78     if (m_frame.document()->inPageCache())
  79         item->setScrollPosition(frameView->cachedScrollPosition());
  80     else
  81         item->setScrollPosition(frameView->scrollPosition());
  82 #if PLATFORM(IOS)
  83     item->setExposedContentRect(frameView->exposedContentRect());
  84     item->setUnobscuredContentRect(frameView->unobscuredContentRect());
  85 #endif
  86
  87     Page* page = m_frame.page();
  88     if (page && m_frame.isMainFrame())
  89         item->setPageScaleFactor(page->pageScaleFactor() / page->viewScaleFactor());
  90
  91     // FIXME: It would be great to work out a way to put this code in WebCore instead of calling through to the client.
  92     m_frame.loader().client().saveViewStateToItem(item);
  93
  94     // Notify clients that the HistoryItem has changed.
  95     item->notifyChanged();
  96 }
  97
  98 void HistoryController::clearScrollPositionAndViewState()
  99 {
 100     if (!m_currentItem)
 101         return;
 102
 103     m_currentItem->clearScrollPosition();
 104     m_currentItem->setPageScaleFactor(0);
 105 }
 106
 107 /*
 108  There is a race condition between the layout and load completion that affects restoring the scroll position.
 109  We try to restore the scroll position at both the first layout and upon load completion.
 110
 111  1) If first layout happens before the load completes, we want to restore the scroll position then so that the
 112  first time we draw the page is already scrolled to the right place, instead of starting at the top and later
 113  jumping down.  It is possible that the old scroll position is past the part of the doc laid out so far, in
 114  which case the restore silent fails and we will fix it in when we try to restore on doc completion.
 115  2) If the layout happens after the load completes, the attempt to restore at load completion time silently
 116  fails.  We then successfully restore it when the layout happens.
 117 */
 118 void HistoryController::restoreScrollPositionAndViewState()
 119 {
 120     if (!m_frame.loader().stateMachine().committedFirstRealDocumentLoad())
 121         return;
 122
 123     ASSERT(m_currentItem);
 124
 125     // FIXME: As the ASSERT attests, it seems we should always have a currentItem here.
 126     // One counterexample is <rdar://problem/4917290>
 127     // For now, to cover this issue in release builds, there is no technical harm to returning
 128     // early and from a user standpoint - as in the above radar - the previous page load failed
 129     // so there *is* no scroll or view state to restore!
 130     if (!m_currentItem)
 131         return;
 132
 133     FrameView* view = m_frame.view();
 134
 135     // FIXME: There is some scrolling related work that needs to happen whenever a page goes into the
 136     // page cache and similar work that needs to occur when it comes out. This is where we do the work
 137     // that needs to happen when we exit, and the work that needs to happen when we enter is in
 138     // Document::setIsInPageCache(bool). It would be nice if there was more symmetry in these spots.
 139     // https://bugs.webkit.org/show_bug.cgi?id=98698
 140     if (view) {
 141         Page* page = m_frame.page();
 142         if (page && m_frame.isMainFrame()) {
 143             if (ScrollingCoordinator* scrollingCoordinator = page->scrollingCoordinator())
 144                 scrollingCoordinator->frameViewRootLayerDidChange(*view);
 145         }
 146     }
 147
 148     // FIXME: It would be great to work out a way to put this code in WebCore instead of calling
 149     // through to the client.
 150     m_frame.loader().client().restoreViewState();
 151
 152 #if !PLATFORM(IOS) && !PLATFORM(EFL)
 153     // Don't restore scroll point on iOS as FrameLoaderClient::restoreViewState() does that.
 154     if (view && !view->wasScrolledByUser()) {
 155         Page* page = m_frame.page();
 156         auto desiredScrollPosition = m_currentItem->scrollPosition();
 157
 158         if (page && m_frame.isMainFrame() && m_currentItem->pageScaleFactor())
 159             page->setPageScaleFactor(m_currentItem->pageScaleFactor() * page->viewScaleFactor(), desiredScrollPosition);
 160         else
 161             view->setScrollPosition(desiredScrollPosition);
 162
 163         // If the scroll position doesn't have to be clamped, consider it successfully restored.
 164         if (m_frame.isMainFrame()) {
 165             auto adjustedDesiredScrollPosition = view->adjustScrollPositionWithinRange(desiredScrollPosition);
 166             if (desiredScrollPosition == adjustedDesiredScrollPosition)
 167                 m_frame.loader().client().didRestoreScrollPosition();
 168         }
 169
 170     }
 171 #endif
 172 }
 173
 174 void HistoryController::updateBackForwardListForFragmentScroll()
 175 {
 176     updateBackForwardListClippedAtTarget(false);
 177 }
 178
 179 void HistoryController::saveDocumentState()
 180 {
 181     // FIXME: Reading this bit of FrameLoader state here is unfortunate.  I need to study
 182     // this more to see if we can remove this dependency.
 183     if (m_frame.loader().stateMachine().creatingInitialEmptyDocument())
 184         return;
 185
 186     // For a standard page load, we will have a previous item set, which will be used to
 187     // store the form state.  However, in some cases we will have no previous item, and
 188     // the current item is the right place to save the state.  One example is when we
 189     // detach a bunch of frames because we are navigating from a site with frames to
 190     // another site.  Another is when saving the frame state of a frame that is not the
 191     // target of the current navigation (if we even decide to save with that granularity).
 192
 193     // Because of previousItem's "masking" of currentItem for this purpose, it's important
 194     // that we keep track of the end of a page transition with m_frameLoadComplete.  We
 195     // leverage the checkLoadComplete recursion to achieve this goal.
 196
 197     HistoryItem* item = m_frameLoadComplete ? m_currentItem.get() : m_previousItem.get();
 198     if (!item)
 199         return;
 200
 201     ASSERT(m_frame.document());
 202     Document& document = *m_frame.document();
 203     if (item->isCurrentDocument(document) && document.hasLivingRenderTree()) {
 204         if (DocumentLoader* documentLoader = document.loader())
 205             item->setShouldOpenExternalURLsPolicy(documentLoader->shouldOpenExternalURLsPolicyToPropagate());
 206
 207         LOG(Loading, "WebCoreLoading %s: saving form state to %p", m_frame.tree().uniqueName().string().utf8().data(), item);
 208         item->setDocumentState(document.formElementsState());
 209     }
 210 }
 211
 212 // Walk the frame tree, telling all frames to save their form state into their current
 213 // history item.
 214 void HistoryController::saveDocumentAndScrollState()
 215 {
 216     for (Frame* frame = &m_frame; frame; frame = frame->tree().traverseNext(&m_frame)) {
 217         frame->loader().history().saveDocumentState();
 218         frame->loader().history().saveScrollPositionAndViewStateToItem(frame->loader().history().currentItem());
 219     }
 220 }
 221
 222 void HistoryController::restoreDocumentState()
 223 {
 224     switch (m_frame.loader().loadType()) {
 225     case FrameLoadType::Reload:
 226     case FrameLoadType::ReloadFromOrigin:
 227     case FrameLoadType::Same:
 228     case FrameLoadType::Replace:
 229         // Not restoring the document state.
 230         return;
 231     case FrameLoadType::Back:
 232     case FrameLoadType::Forward:
 233     case FrameLoadType::IndexedBackForward:
 234     case FrameLoadType::RedirectWithLockedBackForwardList:
 235     case FrameLoadType::Standard:
 236         break;
 237     }
 238
 239     if (!m_currentItem)
 240         return;
 241     if (m_frame.loader().requestedHistoryItem() != m_currentItem.get())
 242         return;
 243     if (m_frame.loader().documentLoader()->isClientRedirect())
 244         return;
 245
 246     m_frame.loader().documentLoader()->setShouldOpenExternalURLsPolicy(m_currentItem->shouldOpenExternalURLsPolicy());
 247
 248     LOG(Loading, "WebCoreLoading %s: restoring form state from %p", m_frame.tree().uniqueName().string().utf8().data(), m_currentItem.get());
 249     m_frame.document()->setStateForNewFormElements(m_currentItem->documentState());
 250 }
 251
 252 void HistoryController::invalidateCurrentItemCachedPage()
 253 {
 254     if (!currentItem())
 255         return;
 256
 257     // When we are pre-commit, the currentItem is where any page cache data resides.
 258     std::unique_ptr<CachedPage> cachedPage = PageCache::singleton().take(*currentItem(), m_frame.page());
 259     if (!cachedPage)
 260         return;
 261
 262     // FIXME: This is a grotesque hack to fix <rdar://problem/4059059> Crash in RenderFlow::detach
 263     // Somehow the PageState object is not properly updated, and is holding onto a stale document.
 264     // Both Xcode and FileMaker see this crash, Safari does not.
 265
 266     ASSERT(cachedPage->document() == m_frame.document());
 267     if (cachedPage->document() == m_frame.document()) {
 268         cachedPage->document()->setInPageCache(false);
 269         cachedPage->clear();
 270     }
 271 }
 272
 273 bool HistoryController::shouldStopLoadingForHistoryItem(HistoryItem& targetItem) const
 274 {
 275     if (!m_currentItem)
 276         return false;
 277
 278     // Don't abort the current load if we're navigating within the current document.
 279     if (m_currentItem->shouldDoSameDocumentNavigationTo(targetItem))
 280         return false;
 281
 282     return true;
 283 }
 284
 285 // Main funnel for navigating to a previous location (back/forward, non-search snap-back)
 286 // This includes recursion to handle loading into framesets properly
 287 void HistoryController::goToItem(HistoryItem& targetItem, FrameLoadType type)
 288 {
 289     ASSERT(!m_frame.tree().parent());
 290
 291     // shouldGoToHistoryItem is a private delegate method. This is needed to fix:
 292     // <rdar://problem/3951283> can view pages from the back/forward cache that should be disallowed by Parental Controls
 293     // Ultimately, history item navigations should go through the policy delegate. That's covered in:
 294     // <rdar://problem/3979539> back/forward cache navigations should consult policy delegate
 295     Page* page = m_frame.page();
 296     if (!page)
 297         return;
 298     if (!m_frame.loader().client().shouldGoToHistoryItem(&targetItem))
 299         return;
 300     if (m_defersLoading) {
 301         m_deferredItem = &targetItem;
 302         m_deferredFrameLoadType = type;
 303         return;
 304     }
 305
 306     // Set the BF cursor before commit, which lets the user quickly click back/forward again.
 307     // - plus, it only makes sense for the top level of the operation through the frame tree,
 308     // as opposed to happening for some/one of the page commits that might happen soon
 309     RefPtr<HistoryItem> currentItem = page->backForward().currentItem();
 310     page->backForward().setCurrentItem(&targetItem);
 311     m_frame.loader().client().updateGlobalHistoryItemForPage();
 312
 313     // First set the provisional item of any frames that are not actually navigating.
 314     // This must be done before trying to navigate the desired frame, because some
 315     // navigations can commit immediately (such as about:blank).  We must be sure that
 316     // all frames have provisional items set before the commit.
 317     recursiveSetProvisionalItem(targetItem, currentItem.get());
 318
 319     // Now that all other frames have provisional items, do the actual navigation.
 320     recursiveGoToItem(targetItem, currentItem.get(), type);
 321 }
 322
 323 void HistoryController::setDefersLoading(bool defer)
 324 {
 325     m_defersLoading = defer;
 326     if (!defer && m_deferredItem) {
 327         goToItem(*m_deferredItem, m_deferredFrameLoadType);
 328         m_deferredItem = nullptr;
 329     }
 330 }
 331
 332 void HistoryController::updateForBackForwardNavigation()
 333 {
 334     LOG(History, "HistoryController %p updateForBackForwardNavigation: Updating History for back/forward navigation in frame %p (main frame %d) %s", this, &m_frame, m_frame.isMainFrame(), m_frame.loader().documentLoader() ? m_frame.loader().documentLoader()->url().string().utf8().data() : "");
 335
 336     // Must grab the current scroll position before disturbing it
 337     if (!m_frameLoadComplete)
 338         saveScrollPositionAndViewStateToItem(m_previousItem.get());
 339
 340     // When traversing history, we may end up redirecting to a different URL
 341     // this time (e.g., due to cookies).  See http://webkit.org/b/49654.
 342     updateCurrentItem();
 343 }
 344
 345 void HistoryController::updateForReload()
 346 {
 347     LOG(History, "HistoryController %p updateForBackForwardNavigation: Updating History for reload in frame %p (main frame %d) %s", this, &m_frame, m_frame.isMainFrame(), m_frame.loader().documentLoader() ? m_frame.loader().documentLoader()->url().string().utf8().data() : "");
 348
 349     if (m_currentItem) {
 350         PageCache::singleton().remove(*m_currentItem);
 351
 352         if (m_frame.loader().loadType() == FrameLoadType::Reload || m_frame.loader().loadType() == FrameLoadType::ReloadFromOrigin)
 353             saveScrollPositionAndViewStateToItem(m_currentItem.get());
 354
 355         // Rebuild the history item tree when reloading as trying to re-associate everything is too error-prone.
 356         m_currentItem->clearChildren();
 357     }
 358
 359     // When reloading the page, we may end up redirecting to a different URL
 360     // this time (e.g., due to cookies).  See http://webkit.org/b/4072.
 361     updateCurrentItem();
 362 }
 363
 364 // There are 3 things you might think of as "history", all of which are handled by these functions.
 365 //
 366 //     1) Back/forward: The m_currentItem is part of this mechanism.
 367 //     2) Global history: Handled by the client.
 368 //     3) Visited links: Handled by the PageGroup.
 369
 370 void HistoryController::updateForStandardLoad(HistoryUpdateType updateType)
 371 {
 372     LOG(History, "HistoryController %p updateForStandardLoad: Updating History for standard load in frame %p (main frame %d) %s", this, &m_frame, m_frame.isMainFrame(), m_frame.loader().documentLoader()->url().string().ascii().data());
 373
 374     FrameLoader& frameLoader = m_frame.loader();
 375
 376     bool needPrivacy = m_frame.page()->usesEphemeralSession();
 377     const URL& historyURL = frameLoader.documentLoader()->urlForHistory();
 378
 379     if (!frameLoader.documentLoader()->isClientRedirect()) {
 380         if (!historyURL.isEmpty()) {
 381             if (updateType != UpdateAllExceptBackForwardList)
 382                 updateBackForwardListClippedAtTarget(true);
 383             if (!needPrivacy) {
 384                 frameLoader.client().updateGlobalHistory();
 385                 frameLoader.documentLoader()->setDidCreateGlobalHistoryEntry(true);
 386                 if (frameLoader.documentLoader()->unreachableURL().isEmpty())
 387                     frameLoader.client().updateGlobalHistoryRedirectLinks();
 388             }
 389
 390             m_frame.loader().client().updateGlobalHistoryItemForPage();
 391         }
 392     } else {
 393         // The client redirect replaces the current history item.
 394         updateCurrentItem();
 395     }
 396
 397     if (!historyURL.isEmpty() && !needPrivacy) {
 398         if (Page* page = m_frame.page())
 399             addVisitedLink(*page, historyURL);
 400
 401         if (!frameLoader.documentLoader()->didCreateGlobalHistoryEntry() && frameLoader.documentLoader()->unreachableURL().isEmpty() && !m_frame.document()->url().isEmpty())
 402             frameLoader.client().updateGlobalHistoryRedirectLinks();
 403     }
 404 }
 405
 406 void HistoryController::updateForRedirectWithLockedBackForwardList()
 407 {
 408     LOG(History, "HistoryController %p updateForRedirectWithLockedBackForwardList: Updating History for redirect load in frame %p (main frame %d) %s", this, &m_frame, m_frame.isMainFrame(), m_frame.loader().documentLoader() ? m_frame.loader().documentLoader()->url().string().utf8().data() : "");
 409
 410     bool needPrivacy = m_frame.page()->usesEphemeralSession();
 411     const URL& historyURL = m_frame.loader().documentLoader()->urlForHistory();
 412
 413     if (m_frame.loader().documentLoader()->isClientRedirect()) {
 414         if (!m_currentItem && !m_frame.tree().parent()) {
 415             if (!historyURL.isEmpty()) {
 416                 updateBackForwardListClippedAtTarget(true);
 417                 if (!needPrivacy) {
 418                     m_frame.loader().client().updateGlobalHistory();
 419                     m_frame.loader().documentLoader()->setDidCreateGlobalHistoryEntry(true);
 420                     if (m_frame.loader().documentLoader()->unreachableURL().isEmpty())
 421                         m_frame.loader().client().updateGlobalHistoryRedirectLinks();
 422                 }
 423
 424                 m_frame.loader().client().updateGlobalHistoryItemForPage();
 425             }
 426         }
 427         // The client redirect replaces the current history item.
 428         updateCurrentItem();
 429     } else {
 430         Frame* parentFrame = m_frame.tree().parent();
 431         if (parentFrame && parentFrame->loader().history().currentItem())
 432             parentFrame->loader().history().currentItem()->setChildItem(createItem());
 433     }
 434
 435     if (!historyURL.isEmpty() && !needPrivacy) {
 436         if (Page* page = m_frame.page())
 437             addVisitedLink(*page, historyURL);
 438
 439         if (!m_frame.loader().documentLoader()->didCreateGlobalHistoryEntry() && m_frame.loader().documentLoader()->unreachableURL().isEmpty() && !m_frame.document()->url().isEmpty())
 440             m_frame.loader().client().updateGlobalHistoryRedirectLinks();
 441     }
 442 }
 443
 444 void HistoryController::updateForClientRedirect()
 445 {
 446     LOG(History, "HistoryController %p updateForClientRedirect: Updating History for client redirect in frame %p (main frame %d) %s", this, &m_frame, m_frame.isMainFrame(), m_frame.loader().documentLoader() ? m_frame.loader().documentLoader()->url().string().utf8().data() : "");
 447
 448     // Clear out form data so we don't try to restore it into the incoming page.  Must happen after
 449     // webcore has closed the URL and saved away the form state.
 450     if (m_currentItem) {
 451         m_currentItem->clearDocumentState();
 452         m_currentItem->clearScrollPosition();
 453     }
 454
 455     bool needPrivacy = m_frame.page()->usesEphemeralSession();
 456     const URL& historyURL = m_frame.loader().documentLoader()->urlForHistory();
 457
 458     if (!historyURL.isEmpty() && !needPrivacy) {
 459         if (Page* page = m_frame.page())
 460             addVisitedLink(*page, historyURL);
 461     }
 462 }
 463
 464 void HistoryController::updateForCommit()
 465 {
 466     FrameLoader& frameLoader = m_frame.loader();
 467     LOG(History, "HistoryController %p updateForCommit: Updating History for commit in frame %p (main frame %d) %s", this, &m_frame, m_frame.isMainFrame(), m_frame.loader().documentLoader() ? m_frame.loader().documentLoader()->url().string().utf8().data() : "");
 468
 469     FrameLoadType type = frameLoader.loadType();
 470     if (isBackForwardLoadType(type)
 471         || isReplaceLoadTypeWithProvisionalItem(type)
 472         || (isReloadTypeWithProvisionalItem(type) && !frameLoader.provisionalDocumentLoader()->unreachableURL().isEmpty())) {
 473         // Once committed, we want to use current item for saving DocState, and
 474         // the provisional item for restoring state.
 475         // Note previousItem must be set before we close the URL, which will
 476         // happen when the data source is made non-provisional below
 477
 478         // FIXME: https://bugs.webkit.org/show_bug.cgi?id=146842
 479         // We should always have a provisional item when committing, but we sometimes don't.
 480         // Not having one leads to us not having a m_currentItem later, which is also a terrible known issue.
 481         // We should get to the bottom of this.
 482         ASSERT(m_provisionalItem);
 483         setCurrentItem(m_provisionalItem.get());
 484         m_provisionalItem = nullptr;
 485
 486         // Tell all other frames in the tree to commit their provisional items and
 487         // restore their scroll position.  We'll avoid this frame (which has already
 488         // committed) and its children (which will be replaced).
 489         m_frame.mainFrame().loader().history().recursiveUpdateForCommit();
 490     }
 491 }
 492
 493 bool HistoryController::isReplaceLoadTypeWithProvisionalItem(FrameLoadType type)
 494 {
 495     // Going back to an error page in a subframe can trigger a FrameLoadType::Replace
 496     // while m_provisionalItem is set, so we need to commit it.
 497     return type == FrameLoadType::Replace && m_provisionalItem;
 498 }
 499
 500 bool HistoryController::isReloadTypeWithProvisionalItem(FrameLoadType type)
 501 {
 502     return (type == FrameLoadType::Reload || type == FrameLoadType::ReloadFromOrigin) && m_provisionalItem;
 503 }
 504
 505 void HistoryController::recursiveUpdateForCommit()
 506 {
 507     // The frame that navigated will now have a null provisional item.
 508     // Ignore it and its children.
 509     if (!m_provisionalItem)
 510         return;
 511
 512     // For each frame that already had the content the item requested (based on
 513     // (a matching URL and frame tree snapshot), just restore the scroll position.
 514     // Save form state (works from currentItem, since m_frameLoadComplete is true)
 515     if (m_currentItem && itemsAreClones(*m_currentItem, m_provisionalItem.get())) {
 516         ASSERT(m_frameLoadComplete);
 517         saveDocumentState();
 518         saveScrollPositionAndViewStateToItem(m_currentItem.get());
 519
 520         if (FrameView* view = m_frame.view())
 521             view->setWasScrolledByUser(false);
 522
 523         // Now commit the provisional item
 524         setCurrentItem(m_provisionalItem.get());
 525         m_provisionalItem = nullptr;
 526
 527         // Restore form state (works from currentItem)
 528         restoreDocumentState();
 529
 530         // Restore the scroll position (we choose to do this rather than going back to the anchor point)
 531         restoreScrollPositionAndViewState();
 532     }
 533
 534     // Iterate over the rest of the tree
 535     for (Frame* child = m_frame.tree().firstChild(); child; child = child->tree().nextSibling())
 536         child->loader().history().recursiveUpdateForCommit();
 537 }
 538
 539 void HistoryController::updateForSameDocumentNavigation()
 540 {
 541     if (m_frame.document()->url().isEmpty())
 542         return;
 543
 544     if (m_frame.page()->usesEphemeralSession())
 545         return;
 546
 547     Page* page = m_frame.page();
 548     if (!page)
 549         return;
 550
 551     addVisitedLink(*page, m_frame.document()->url());
 552     m_frame.mainFrame().loader().history().recursiveUpdateForSameDocumentNavigation();
 553
 554     if (m_currentItem) {
 555         m_currentItem->setURL(m_frame.document()->url());
 556         m_frame.loader().client().updateGlobalHistory();
 557     }
 558 }
 559
 560 void HistoryController::recursiveUpdateForSameDocumentNavigation()
 561 {
 562     // The frame that navigated will now have a null provisional item.
 563     // Ignore it and its children.
 564     if (!m_provisionalItem)
 565         return;
 566
 567     // The provisional item may represent a different pending navigation.
 568     // Don't commit it if it isn't a same document navigation.
 569     if (m_currentItem && !m_currentItem->shouldDoSameDocumentNavigationTo(*m_provisionalItem))
 570         return;
 571
 572     // Commit the provisional item.
 573     setCurrentItem(m_provisionalItem.get());
 574     m_provisionalItem = nullptr;
 575
 576     // Iterate over the rest of the tree.
 577     for (Frame* child = m_frame.tree().firstChild(); child; child = child->tree().nextSibling())
 578         child->loader().history().recursiveUpdateForSameDocumentNavigation();
 579 }
 580
 581 void HistoryController::updateForFrameLoadCompleted()
 582 {
 583     // Even if already complete, we might have set a previous item on a frame that
 584     // didn't do any data loading on the past transaction. Make sure to track that
 585     // the load is complete so that we use the current item instead.
 586     m_frameLoadComplete = true;
 587 }
 588
 589 void HistoryController::setCurrentItem(HistoryItem* item)
 590 {
 591     m_frameLoadComplete = false;
 592     m_previousItem = m_currentItem;
 593     m_currentItem = item;
 594 }
 595
 596 void HistoryController::setCurrentItemTitle(const StringWithDirection& title)
 597 {
 598     if (m_currentItem)
 599         // FIXME: make use of title.direction() as well.
 600         m_currentItem->setTitle(title.string());
 601 }
 602
 603 bool HistoryController::currentItemShouldBeReplaced() const
 604 {
 605     // From the HTML5 spec for location.assign():
 606     //  "If the browsing context's session history contains only one Document,
 607     //   and that was the about:blank Document created when the browsing context
 608     //   was created, then the navigation must be done with replacement enabled."
 609     return m_currentItem && !m_previousItem && equalIgnoringASCIICase(m_currentItem->urlString(), blankURL());
 610 }
 611
 612 void HistoryController::clearPreviousItem()
 613 {
 614     m_previousItem = nullptr;
 615     for (Frame* child = m_frame.tree().firstChild(); child; child = child->tree().nextSibling())
 616         child->loader().history().clearPreviousItem();
 617 }
 618
 619 void HistoryController::setProvisionalItem(HistoryItem* item)
 620 {
 621     m_provisionalItem = item;
 622 }
 623
 624 void HistoryController::initializeItem(HistoryItem& item)
 625 {
 626     DocumentLoader* documentLoader = m_frame.loader().documentLoader();
 627     ASSERT(documentLoader);
 628
 629     URL unreachableURL = documentLoader->unreachableURL();
 630
 631     URL url;
 632     URL originalURL;
 633
 634     if (!unreachableURL.isEmpty()) {
 635         url = unreachableURL;
 636         originalURL = unreachableURL;
 637     } else {
 638         url = documentLoader->url();
 639         originalURL = documentLoader->originalURL();
 640     }
 641
 642     // Frames that have never successfully loaded any content
 643     // may have no URL at all. Currently our history code can't
 644     // deal with such things, so we nip that in the bud here.
 645     // Later we may want to learn to live with nil for URL.
 646     // See bug 3368236 and related bugs for more information.
 647     if (url.isEmpty())
 648         url = blankURL();
 649     if (originalURL.isEmpty())
 650         originalURL = blankURL();
 651
 652     StringWithDirection title = documentLoader->title();
 653
 654     item.setURL(url);
 655     item.setTarget(m_frame.tree().uniqueName());
 656     // FIXME: should store title directionality in history as well.
 657     item.setTitle(title.string());
 658     item.setOriginalURLString(originalURL.string());
 659
 660     if (!unreachableURL.isEmpty() || documentLoader->response().httpStatusCode() >= 400)
 661         item.setLastVisitWasFailure(true);
 662
 663     item.setShouldOpenExternalURLsPolicy(documentLoader->shouldOpenExternalURLsPolicyToPropagate());
 664
 665     // Save form state if this is a POST
 666     item.setFormInfoFromRequest(documentLoader->request());
 667 }
 668
 669 Ref<HistoryItem> HistoryController::createItem()
 670 {
 671     Ref<HistoryItem> item = HistoryItem::create();
 672     initializeItem(item);
 673
 674     // Set the item for which we will save document state
 675     setCurrentItem(item.ptr());
 676
 677     return item;
 678 }
 679
 680 Ref<HistoryItem> HistoryController::createItemTree(Frame& targetFrame, bool clipAtTarget)
 681 {
 682     Ref<HistoryItem> bfItem = createItem();
 683     if (!m_frameLoadComplete)
 684         saveScrollPositionAndViewStateToItem(m_previousItem.get());
 685
 686     if (!clipAtTarget || &m_frame != &targetFrame) {
 687         // save frame state for items that aren't loading (khtml doesn't save those)
 688         saveDocumentState();
 689
 690         // clipAtTarget is false for navigations within the same document, so
 691         // we should copy the documentSequenceNumber over to the newly create
 692         // item.  Non-target items are just clones, and they should therefore
 693         // preserve the same itemSequenceNumber.
 694         if (m_previousItem) {
 695             if (&m_frame != &targetFrame)
 696                 bfItem->setItemSequenceNumber(m_previousItem->itemSequenceNumber());
 697             bfItem->setDocumentSequenceNumber(m_previousItem->documentSequenceNumber());
 698         }
 699
 700         for (Frame* child = m_frame.tree().firstChild(); child; child = child->tree().nextSibling()) {
 701             FrameLoader& childLoader = child->loader();
 702             bool hasChildLoaded = childLoader.frameHasLoaded();
 703
 704             // If the child is a frame corresponding to an <object> element that never loaded,
 705             // we don't want to create a history item, because that causes fallback content
 706             // to be ignored on reload.
 707
 708             if (!(!hasChildLoaded && childLoader.isHostedByObjectElement()))
 709                 bfItem->addChildItem(childLoader.history().createItemTree(targetFrame, clipAtTarget));
 710         }
 711     }
 712     // FIXME: Eliminate the isTargetItem flag in favor of itemSequenceNumber.
 713     if (&m_frame == &targetFrame)
 714         bfItem->setIsTargetItem(true);
 715     return bfItem;
 716 }
 717
 718 // The general idea here is to traverse the frame tree and the item tree in parallel,
 719 // tracking whether each frame already has the content the item requests.  If there is
 720 // a match, we set the provisional item and recurse.  Otherwise we will reload that
 721 // frame and all its kids in recursiveGoToItem.
 722 void HistoryController::recursiveSetProvisionalItem(HistoryItem& item, HistoryItem* fromItem)
 723 {
 724     if (!itemsAreClones(item, fromItem))
 725         return;
 726
 727     // Set provisional item, which will be committed in recursiveUpdateForCommit.
 728     m_provisionalItem = &item;
 729
 730     for (auto& childItem : item.children()) {
 731         const String& childFrameName = childItem->target();
 732
 733         HistoryItem* fromChildItem = fromItem->childItemWithTarget(childFrameName);
 734         ASSERT(fromChildItem);
 735         Frame* childFrame = m_frame.tree().child(childFrameName);
 736         ASSERT(childFrame);
 737
 738         childFrame->loader().history().recursiveSetProvisionalItem(const_cast<HistoryItem&>(childItem.get()), fromChildItem);
 739     }
 740 }
 741
 742 // We now traverse the frame tree and item tree a second time, loading frames that
 743 // do have the content the item requests.
 744 void HistoryController::recursiveGoToItem(HistoryItem& item, HistoryItem* fromItem, FrameLoadType type)
 745 {
 746     if (!itemsAreClones(item, fromItem)) {
 747         m_frame.loader().loadItem(item, type);
 748         return;
 749     }
 750
 751     // Just iterate over the rest, looking for frames to navigate.
 752     for (auto& childItem : item.children()) {
 753         const String& childFrameName = childItem->target();
 754
 755         HistoryItem* fromChildItem = fromItem->childItemWithTarget(childFrameName);
 756         ASSERT(fromChildItem);
 757         if (Frame* childFrame = m_frame.tree().child(childFrameName))
 758             childFrame->loader().history().recursiveGoToItem(const_cast<HistoryItem&>(childItem.get()), fromChildItem, type);
 759     }
 760 }
 761
 762 bool HistoryController::itemsAreClones(HistoryItem& item1, HistoryItem* item2) const
 763 {
 764     // If the item we're going to is a clone of the item we're at, then we do
 765     // not need to load it again.  The current frame tree and the frame tree
 766     // snapshot in the item have to match.
 767     // Note: Some clients treat a navigation to the current history item as
 768     // a reload.  Thus, if item1 and item2 are the same, we need to create a
 769     // new document and should not consider them clones.
 770     // (See http://webkit.org/b/35532 for details.)
 771     return item2
 772         && &item1 != item2
 773         && item1.itemSequenceNumber() == item2->itemSequenceNumber()
 774         && currentFramesMatchItem(&item1)
 775         && item2->hasSameFrames(item1);
 776 }
 777
 778 // Helper method that determines whether the current frame tree matches given history item's.
 779 bool HistoryController::currentFramesMatchItem(HistoryItem* item) const
 780 {
 781     if ((!m_frame.tree().uniqueName().isEmpty() || !item->target().isEmpty()) && m_frame.tree().uniqueName() != item->target())
 782         return false;
 783
 784     const HistoryItemVector& childItems = item->children();
 785     if (childItems.size() != m_frame.tree().childCount())
 786         return false;
 787
 788     for (auto& item : childItems) {
 789         if (!m_frame.tree().child(item->target()))
 790             return false;
 791     }
 792
 793     return true;
 794 }
 795
 796 void HistoryController::updateBackForwardListClippedAtTarget(bool doClip)
 797 {
 798     // In the case of saving state about a page with frames, we store a tree of items that mirrors the frame tree.
 799     // The item that was the target of the user's navigation is designated as the "targetItem".
 800     // When this function is called with doClip=true we're able to create the whole tree except for the target's children,
 801     // which will be loaded in the future. That part of the tree will be filled out as the child loads are committed.
 802
 803     Page* page = m_frame.page();
 804     if (!page)
 805         return;
 806
 807     if (m_frame.loader().documentLoader()->urlForHistory().isEmpty())
 808         return;
 809
 810     FrameLoader& frameLoader = m_frame.mainFrame().loader();
 811
 812     Ref<HistoryItem> topItem = frameLoader.history().createItemTree(m_frame, doClip);
 813     LOG(History, "HistoryController %p updateBackForwardListClippedAtTarget: Adding backforward item %p in frame %p (main frame %d) %s", this, topItem.ptr(), &m_frame, m_frame.isMainFrame(), m_frame.loader().documentLoader()->url().string().utf8().data());
 814
 815     page->backForward().addItem(WTFMove(topItem));
 816 }
 817
 818 void HistoryController::updateCurrentItem()
 819 {
 820     if (!m_currentItem)
 821         return;
 822
 823     DocumentLoader* documentLoader = m_frame.loader().documentLoader();
 824
 825     if (!documentLoader->unreachableURL().isEmpty())
 826         return;
 827
 828     if (m_currentItem->url() != documentLoader->url()) {
 829         // We ended up on a completely different URL this time, so the HistoryItem
 830         // needs to be re-initialized.  Preserve the isTargetItem flag as it is a
 831         // property of how this HistoryItem was originally created and is not
 832         // dependent on the document.
 833         bool isTargetItem = m_currentItem->isTargetItem();
 834         m_currentItem->reset();
 835         initializeItem(*m_currentItem);
 836         m_currentItem->setIsTargetItem(isTargetItem);
 837     } else {
 838         // Even if the final URL didn't change, the form data may have changed.
 839         m_currentItem->setFormInfoFromRequest(documentLoader->request());
 840     }
 841 }
 842
 843 void HistoryController::pushState(PassRefPtr<SerializedScriptValue> stateObject, const String& title, const String& urlString)
 844 {
 845     if (!m_currentItem)
 846         return;
 847
 848     Page* page = m_frame.page();
 849     ASSERT(page);
 850
 851     // Get a HistoryItem tree for the current frame tree.
 852     Ref<HistoryItem> topItem = m_frame.mainFrame().loader().history().createItemTree(m_frame, false);
 853
 854     // Override data in the current item (created by createItemTree) to reflect
 855     // the pushState() arguments.
 856     m_currentItem->setTitle(title);
 857     m_currentItem->setStateObject(stateObject);
 858     m_currentItem->setURLString(urlString);
 859
 860     LOG(History, "HistoryController %p pushState: Adding top item %p, setting url of current item %p to %s", this, topItem.ptr(), m_currentItem.get(), urlString.ascii().data());
 861
 862     page->backForward().addItem(WTFMove(topItem));
 863
 864     if (m_frame.page()->usesEphemeralSession())
 865         return;
 866
 867     addVisitedLink(*page, URL(ParsedURLString, urlString));
 868     m_frame.loader().client().updateGlobalHistory();
 869 }
 870
 871 void HistoryController::replaceState(PassRefPtr<SerializedScriptValue> stateObject, const String& title, const String& urlString)
 872 {
 873     if (!m_currentItem)
 874         return;
 875
 876     LOG(History, "HistoryController %p replaceState: Setting url of current item %p to %s", this, m_currentItem.get(), urlString.ascii().data());
 877
 878     if (!urlString.isEmpty())
 879         m_currentItem->setURLString(urlString);
 880     m_currentItem->setTitle(title);
 881     m_currentItem->setStateObject(stateObject);
 882     m_currentItem->setFormData(nullptr);
 883     m_currentItem->setFormContentType(String());
 884
 885     if (m_frame.page()->usesEphemeralSession())
 886         return;
 887
 888     ASSERT(m_frame.page());
 889     addVisitedLink(*m_frame.page(), URL(ParsedURLString, urlString));
 890     m_frame.loader().client().updateGlobalHistory();
 891 }
 892
 893 void HistoryController::replaceCurrentItem(HistoryItem* item)
 894 {
 895     if (!item)
 896         return;
 897
 898     m_previousItem = nullptr;
 899     if (m_provisionalItem)
 900         m_provisionalItem = item;
 901     else
 902         m_currentItem = item;
 903 }
 904
 905 } // namespace WebCore