Improve the history logging output
[WebKit-https.git] / 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->setScrollPoint(frameView->cachedScrollPosition());
80     else
81         item->setScrollPoint(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->clearScrollPoint();
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         if (page && m_frame.isMainFrame() && m_currentItem->pageScaleFactor())
157             page->setPageScaleFactor(m_currentItem->pageScaleFactor() * page->viewScaleFactor(), m_currentItem->scrollPoint());
158         else
159             view->setScrollPosition(m_currentItem->scrollPoint());
160     }
161 #endif
162 }
163
164 void HistoryController::updateBackForwardListForFragmentScroll()
165 {
166     updateBackForwardListClippedAtTarget(false);
167 }
168
169 void HistoryController::saveDocumentState()
170 {
171     // FIXME: Reading this bit of FrameLoader state here is unfortunate.  I need to study
172     // this more to see if we can remove this dependency.
173     if (m_frame.loader().stateMachine().creatingInitialEmptyDocument())
174         return;
175
176     // For a standard page load, we will have a previous item set, which will be used to
177     // store the form state.  However, in some cases we will have no previous item, and
178     // the current item is the right place to save the state.  One example is when we
179     // detach a bunch of frames because we are navigating from a site with frames to
180     // another site.  Another is when saving the frame state of a frame that is not the
181     // target of the current navigation (if we even decide to save with that granularity).
182
183     // Because of previousItem's "masking" of currentItem for this purpose, it's important
184     // that we keep track of the end of a page transition with m_frameLoadComplete.  We
185     // leverage the checkLoadComplete recursion to achieve this goal.
186
187     HistoryItem* item = m_frameLoadComplete ? m_currentItem.get() : m_previousItem.get();
188     if (!item)
189         return;
190
191     ASSERT(m_frame.document());
192     Document& document = *m_frame.document();
193     if (item->isCurrentDocument(document) && document.hasLivingRenderTree()) {
194         LOG(Loading, "WebCoreLoading %s: saving form state to %p", m_frame.tree().uniqueName().string().utf8().data(), item);
195         item->setDocumentState(document.formElementsState());
196     }
197 }
198
199 // Walk the frame tree, telling all frames to save their form state into their current
200 // history item.
201 void HistoryController::saveDocumentAndScrollState()
202 {
203     for (Frame* frame = &m_frame; frame; frame = frame->tree().traverseNext(&m_frame)) {
204         frame->loader().history().saveDocumentState();
205         frame->loader().history().saveScrollPositionAndViewStateToItem(frame->loader().history().currentItem());
206     }
207 }
208
209 void HistoryController::restoreDocumentState()
210 {
211     switch (m_frame.loader().loadType()) {
212     case FrameLoadType::Reload:
213     case FrameLoadType::ReloadFromOrigin:
214     case FrameLoadType::Same:
215     case FrameLoadType::Replace:
216         // Not restoring the document state.
217         return;
218     case FrameLoadType::Back:
219     case FrameLoadType::Forward:
220     case FrameLoadType::IndexedBackForward:
221     case FrameLoadType::RedirectWithLockedBackForwardList:
222     case FrameLoadType::Standard:
223         break;
224     }
225     
226     if (!m_currentItem)
227         return;
228     if (m_frame.loader().requestedHistoryItem() != m_currentItem.get())
229         return;
230     if (m_frame.loader().documentLoader()->isClientRedirect())
231         return;
232
233     LOG(Loading, "WebCoreLoading %s: restoring form state from %p", m_frame.tree().uniqueName().string().utf8().data(), m_currentItem.get());
234     m_frame.document()->setStateForNewFormElements(m_currentItem->documentState());
235 }
236
237 void HistoryController::invalidateCurrentItemCachedPage()
238 {
239     if (!currentItem())
240         return;
241
242     // When we are pre-commit, the currentItem is where any page cache data resides.
243     std::unique_ptr<CachedPage> cachedPage = PageCache::singleton().take(*currentItem(), m_frame.page());
244     if (!cachedPage)
245         return;
246
247     // FIXME: This is a grotesque hack to fix <rdar://problem/4059059> Crash in RenderFlow::detach
248     // Somehow the PageState object is not properly updated, and is holding onto a stale document.
249     // Both Xcode and FileMaker see this crash, Safari does not.
250     
251     ASSERT(cachedPage->document() == m_frame.document());
252     if (cachedPage->document() == m_frame.document()) {
253         cachedPage->document()->setInPageCache(false);
254         cachedPage->clear();
255     }
256 }
257
258 bool HistoryController::shouldStopLoadingForHistoryItem(HistoryItem& targetItem) const
259 {
260     if (!m_currentItem)
261         return false;
262
263     // Don't abort the current load if we're navigating within the current document.
264     if (m_currentItem->shouldDoSameDocumentNavigationTo(targetItem))
265         return false;
266
267     return true;
268 }
269
270 // Main funnel for navigating to a previous location (back/forward, non-search snap-back)
271 // This includes recursion to handle loading into framesets properly
272 void HistoryController::goToItem(HistoryItem& targetItem, FrameLoadType type)
273 {
274     ASSERT(!m_frame.tree().parent());
275     
276     // shouldGoToHistoryItem is a private delegate method. This is needed to fix:
277     // <rdar://problem/3951283> can view pages from the back/forward cache that should be disallowed by Parental Controls
278     // Ultimately, history item navigations should go through the policy delegate. That's covered in:
279     // <rdar://problem/3979539> back/forward cache navigations should consult policy delegate
280     Page* page = m_frame.page();
281     if (!page)
282         return;
283     if (!m_frame.loader().client().shouldGoToHistoryItem(&targetItem))
284         return;
285     if (m_defersLoading) {
286         m_deferredItem = &targetItem;
287         m_deferredFrameLoadType = type;
288         return;
289     }
290
291     // Set the BF cursor before commit, which lets the user quickly click back/forward again.
292     // - plus, it only makes sense for the top level of the operation through the frame tree,
293     // as opposed to happening for some/one of the page commits that might happen soon
294     RefPtr<HistoryItem> currentItem = page->backForward().currentItem();
295     page->backForward().setCurrentItem(&targetItem);
296     m_frame.loader().client().updateGlobalHistoryItemForPage();
297
298     // First set the provisional item of any frames that are not actually navigating.
299     // This must be done before trying to navigate the desired frame, because some
300     // navigations can commit immediately (such as about:blank).  We must be sure that
301     // all frames have provisional items set before the commit.
302     recursiveSetProvisionalItem(targetItem, currentItem.get());
303
304     // Now that all other frames have provisional items, do the actual navigation.
305     recursiveGoToItem(targetItem, currentItem.get(), type);
306 }
307
308 void HistoryController::setDefersLoading(bool defer)
309 {
310     m_defersLoading = defer;
311     if (!defer && m_deferredItem) {
312         goToItem(*m_deferredItem, m_deferredFrameLoadType);
313         m_deferredItem = nullptr;
314     }
315 }
316
317 void HistoryController::updateForBackForwardNavigation()
318 {
319     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() : "");
320
321     // Must grab the current scroll position before disturbing it
322     if (!m_frameLoadComplete)
323         saveScrollPositionAndViewStateToItem(m_previousItem.get());
324
325     // When traversing history, we may end up redirecting to a different URL
326     // this time (e.g., due to cookies).  See http://webkit.org/b/49654.
327     updateCurrentItem();
328 }
329
330 void HistoryController::updateForReload()
331 {
332     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() : "");
333
334     if (m_currentItem) {
335         PageCache::singleton().remove(*m_currentItem);
336     
337         if (m_frame.loader().loadType() == FrameLoadType::Reload || m_frame.loader().loadType() == FrameLoadType::ReloadFromOrigin)
338             saveScrollPositionAndViewStateToItem(m_currentItem.get());
339
340         // Rebuild the history item tree when reloading as trying to re-associate everything is too error-prone.
341         m_currentItem->clearChildren();
342     }
343
344     // When reloading the page, we may end up redirecting to a different URL
345     // this time (e.g., due to cookies).  See http://webkit.org/b/4072.
346     updateCurrentItem();
347 }
348
349 // There are 3 things you might think of as "history", all of which are handled by these functions.
350 //
351 //     1) Back/forward: The m_currentItem is part of this mechanism.
352 //     2) Global history: Handled by the client.
353 //     3) Visited links: Handled by the PageGroup.
354
355 void HistoryController::updateForStandardLoad(HistoryUpdateType updateType)
356 {
357     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());
358
359     FrameLoader& frameLoader = m_frame.loader();
360
361     bool needPrivacy = m_frame.page()->usesEphemeralSession();
362     const URL& historyURL = frameLoader.documentLoader()->urlForHistory();
363
364     if (!frameLoader.documentLoader()->isClientRedirect()) {
365         if (!historyURL.isEmpty()) {
366             if (updateType != UpdateAllExceptBackForwardList)
367                 updateBackForwardListClippedAtTarget(true);
368             if (!needPrivacy) {
369                 frameLoader.client().updateGlobalHistory();
370                 frameLoader.documentLoader()->setDidCreateGlobalHistoryEntry(true);
371                 if (frameLoader.documentLoader()->unreachableURL().isEmpty())
372                     frameLoader.client().updateGlobalHistoryRedirectLinks();
373             }
374
375             m_frame.loader().client().updateGlobalHistoryItemForPage();
376         }
377     } else {
378         // The client redirect replaces the current history item.
379         updateCurrentItem();
380     }
381
382     if (!historyURL.isEmpty() && !needPrivacy) {
383         if (Page* page = m_frame.page())
384             addVisitedLink(*page, historyURL);
385
386         if (!frameLoader.documentLoader()->didCreateGlobalHistoryEntry() && frameLoader.documentLoader()->unreachableURL().isEmpty() && !m_frame.document()->url().isEmpty())
387             frameLoader.client().updateGlobalHistoryRedirectLinks();
388     }
389 }
390
391 void HistoryController::updateForRedirectWithLockedBackForwardList()
392 {
393     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() : "");
394     
395     bool needPrivacy = m_frame.page()->usesEphemeralSession();
396     const URL& historyURL = m_frame.loader().documentLoader()->urlForHistory();
397
398     if (m_frame.loader().documentLoader()->isClientRedirect()) {
399         if (!m_currentItem && !m_frame.tree().parent()) {
400             if (!historyURL.isEmpty()) {
401                 updateBackForwardListClippedAtTarget(true);
402                 if (!needPrivacy) {
403                     m_frame.loader().client().updateGlobalHistory();
404                     m_frame.loader().documentLoader()->setDidCreateGlobalHistoryEntry(true);
405                     if (m_frame.loader().documentLoader()->unreachableURL().isEmpty())
406                         m_frame.loader().client().updateGlobalHistoryRedirectLinks();
407                 }
408
409                 m_frame.loader().client().updateGlobalHistoryItemForPage();
410             }
411         }
412         // The client redirect replaces the current history item.
413         updateCurrentItem();
414     } else {
415         Frame* parentFrame = m_frame.tree().parent();
416         if (parentFrame && parentFrame->loader().history().currentItem())
417             parentFrame->loader().history().currentItem()->setChildItem(createItem());
418     }
419
420     if (!historyURL.isEmpty() && !needPrivacy) {
421         if (Page* page = m_frame.page())
422             addVisitedLink(*page, historyURL);
423
424         if (!m_frame.loader().documentLoader()->didCreateGlobalHistoryEntry() && m_frame.loader().documentLoader()->unreachableURL().isEmpty() && !m_frame.document()->url().isEmpty())
425             m_frame.loader().client().updateGlobalHistoryRedirectLinks();
426     }
427 }
428
429 void HistoryController::updateForClientRedirect()
430 {
431     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() : "");
432
433     // Clear out form data so we don't try to restore it into the incoming page.  Must happen after
434     // webcore has closed the URL and saved away the form state.
435     if (m_currentItem) {
436         m_currentItem->clearDocumentState();
437         m_currentItem->clearScrollPoint();
438     }
439
440     bool needPrivacy = m_frame.page()->usesEphemeralSession();
441     const URL& historyURL = m_frame.loader().documentLoader()->urlForHistory();
442
443     if (!historyURL.isEmpty() && !needPrivacy) {
444         if (Page* page = m_frame.page())
445             addVisitedLink(*page, historyURL);
446     }
447 }
448
449 void HistoryController::updateForCommit()
450 {
451     FrameLoader& frameLoader = m_frame.loader();
452     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() : "");
453
454     FrameLoadType type = frameLoader.loadType();
455     if (isBackForwardLoadType(type)
456         || isReplaceLoadTypeWithProvisionalItem(type)
457         || (isReloadTypeWithProvisionalItem(type) && !frameLoader.provisionalDocumentLoader()->unreachableURL().isEmpty())) {
458         // Once committed, we want to use current item for saving DocState, and
459         // the provisional item for restoring state.
460         // Note previousItem must be set before we close the URL, which will
461         // happen when the data source is made non-provisional below
462
463         // FIXME: https://bugs.webkit.org/show_bug.cgi?id=146842
464         // We should always have a provisional item when committing, but we sometimes don't.
465         // Not having one leads to us not having a m_currentItem later, which is also a terrible known issue.
466         // We should get to the bottom of this.
467         ASSERT(m_provisionalItem);
468         setCurrentItem(m_provisionalItem.get());
469         m_provisionalItem = nullptr;
470
471         // Tell all other frames in the tree to commit their provisional items and
472         // restore their scroll position.  We'll avoid this frame (which has already
473         // committed) and its children (which will be replaced).
474         m_frame.mainFrame().loader().history().recursiveUpdateForCommit();
475     }
476 }
477
478 bool HistoryController::isReplaceLoadTypeWithProvisionalItem(FrameLoadType type)
479 {
480     // Going back to an error page in a subframe can trigger a FrameLoadType::Replace
481     // while m_provisionalItem is set, so we need to commit it.
482     return type == FrameLoadType::Replace && m_provisionalItem;
483 }
484
485 bool HistoryController::isReloadTypeWithProvisionalItem(FrameLoadType type)
486 {
487     return (type == FrameLoadType::Reload || type == FrameLoadType::ReloadFromOrigin) && m_provisionalItem;
488 }
489
490 void HistoryController::recursiveUpdateForCommit()
491 {
492     // The frame that navigated will now have a null provisional item.
493     // Ignore it and its children.
494     if (!m_provisionalItem)
495         return;
496
497     // For each frame that already had the content the item requested (based on
498     // (a matching URL and frame tree snapshot), just restore the scroll position.
499     // Save form state (works from currentItem, since m_frameLoadComplete is true)
500     if (m_currentItem && itemsAreClones(*m_currentItem, m_provisionalItem.get())) {
501         ASSERT(m_frameLoadComplete);
502         saveDocumentState();
503         saveScrollPositionAndViewStateToItem(m_currentItem.get());
504
505         if (FrameView* view = m_frame.view())
506             view->setWasScrolledByUser(false);
507
508         // Now commit the provisional item
509         setCurrentItem(m_provisionalItem.get());
510         m_provisionalItem = nullptr;
511
512         // Restore form state (works from currentItem)
513         restoreDocumentState();
514
515         // Restore the scroll position (we choose to do this rather than going back to the anchor point)
516         restoreScrollPositionAndViewState();
517     }
518
519     // Iterate over the rest of the tree
520     for (Frame* child = m_frame.tree().firstChild(); child; child = child->tree().nextSibling())
521         child->loader().history().recursiveUpdateForCommit();
522 }
523
524 void HistoryController::updateForSameDocumentNavigation()
525 {
526     if (m_frame.document()->url().isEmpty())
527         return;
528
529     if (m_frame.page()->usesEphemeralSession())
530         return;
531
532     Page* page = m_frame.page();
533     if (!page)
534         return;
535
536     addVisitedLink(*page, m_frame.document()->url());
537     m_frame.mainFrame().loader().history().recursiveUpdateForSameDocumentNavigation();
538
539     if (m_currentItem) {
540         m_currentItem->setURL(m_frame.document()->url());
541         m_frame.loader().client().updateGlobalHistory();
542     }
543 }
544
545 void HistoryController::recursiveUpdateForSameDocumentNavigation()
546 {
547     // The frame that navigated will now have a null provisional item.
548     // Ignore it and its children.
549     if (!m_provisionalItem)
550         return;
551
552     // The provisional item may represent a different pending navigation.
553     // Don't commit it if it isn't a same document navigation.
554     if (m_currentItem && !m_currentItem->shouldDoSameDocumentNavigationTo(*m_provisionalItem))
555         return;
556
557     // Commit the provisional item.
558     setCurrentItem(m_provisionalItem.get());
559     m_provisionalItem = nullptr;
560
561     // Iterate over the rest of the tree.
562     for (Frame* child = m_frame.tree().firstChild(); child; child = child->tree().nextSibling())
563         child->loader().history().recursiveUpdateForSameDocumentNavigation();
564 }
565
566 void HistoryController::updateForFrameLoadCompleted()
567 {
568     // Even if already complete, we might have set a previous item on a frame that
569     // didn't do any data loading on the past transaction. Make sure to track that
570     // the load is complete so that we use the current item instead.
571     m_frameLoadComplete = true;
572 }
573
574 void HistoryController::setCurrentItem(HistoryItem* item)
575 {
576     m_frameLoadComplete = false;
577     m_previousItem = m_currentItem;
578     m_currentItem = item;
579 }
580
581 void HistoryController::setCurrentItemTitle(const StringWithDirection& title)
582 {
583     if (m_currentItem)
584         // FIXME: make use of title.direction() as well.
585         m_currentItem->setTitle(title.string());
586 }
587
588 bool HistoryController::currentItemShouldBeReplaced() const
589 {
590     // From the HTML5 spec for location.assign():
591     //  "If the browsing context's session history contains only one Document,
592     //   and that was the about:blank Document created when the browsing context
593     //   was created, then the navigation must be done with replacement enabled."
594     return m_currentItem && !m_previousItem && equalIgnoringCase(m_currentItem->urlString(), blankURL());
595 }
596
597 void HistoryController::clearPreviousItem()
598 {
599     m_previousItem = nullptr;
600     for (Frame* child = m_frame.tree().firstChild(); child; child = child->tree().nextSibling())
601         child->loader().history().clearPreviousItem();
602 }
603
604 void HistoryController::setProvisionalItem(HistoryItem* item)
605 {
606     m_provisionalItem = item;
607 }
608
609 void HistoryController::initializeItem(HistoryItem& item)
610 {
611     DocumentLoader* documentLoader = m_frame.loader().documentLoader();
612     ASSERT(documentLoader);
613
614     URL unreachableURL = documentLoader->unreachableURL();
615
616     URL url;
617     URL originalURL;
618
619     if (!unreachableURL.isEmpty()) {
620         url = unreachableURL;
621         originalURL = unreachableURL;
622     } else {
623         url = documentLoader->url();
624         originalURL = documentLoader->originalURL();
625     }
626
627     // Frames that have never successfully loaded any content
628     // may have no URL at all. Currently our history code can't
629     // deal with such things, so we nip that in the bud here.
630     // Later we may want to learn to live with nil for URL.
631     // See bug 3368236 and related bugs for more information.
632     if (url.isEmpty()) 
633         url = blankURL();
634     if (originalURL.isEmpty())
635         originalURL = blankURL();
636     
637     Frame* parentFrame = m_frame.tree().parent();
638     String parent = parentFrame ? parentFrame->tree().uniqueName() : "";
639     StringWithDirection title = documentLoader->title();
640
641     item.setURL(url);
642     item.setTarget(m_frame.tree().uniqueName());
643     item.setParent(parent);
644     // FIXME: should store title directionality in history as well.
645     item.setTitle(title.string());
646     item.setOriginalURLString(originalURL.string());
647
648     if (!unreachableURL.isEmpty() || documentLoader->response().httpStatusCode() >= 400)
649         item.setLastVisitWasFailure(true);
650
651     // Save form state if this is a POST
652     item.setFormInfoFromRequest(documentLoader->request());
653 }
654
655 Ref<HistoryItem> HistoryController::createItem()
656 {
657     Ref<HistoryItem> item = HistoryItem::create();
658     initializeItem(item);
659     
660     // Set the item for which we will save document state
661     setCurrentItem(item.ptr());
662     
663     return item;
664 }
665
666 Ref<HistoryItem> HistoryController::createItemTree(Frame& targetFrame, bool clipAtTarget)
667 {
668     Ref<HistoryItem> bfItem = createItem();
669     if (!m_frameLoadComplete)
670         saveScrollPositionAndViewStateToItem(m_previousItem.get());
671
672     if (!clipAtTarget || &m_frame != &targetFrame) {
673         // save frame state for items that aren't loading (khtml doesn't save those)
674         saveDocumentState();
675
676         // clipAtTarget is false for navigations within the same document, so
677         // we should copy the documentSequenceNumber over to the newly create
678         // item.  Non-target items are just clones, and they should therefore
679         // preserve the same itemSequenceNumber.
680         if (m_previousItem) {
681             if (&m_frame != &targetFrame)
682                 bfItem->setItemSequenceNumber(m_previousItem->itemSequenceNumber());
683             bfItem->setDocumentSequenceNumber(m_previousItem->documentSequenceNumber());
684         }
685
686         for (Frame* child = m_frame.tree().firstChild(); child; child = child->tree().nextSibling()) {
687             FrameLoader& childLoader = child->loader();
688             bool hasChildLoaded = childLoader.frameHasLoaded();
689
690             // If the child is a frame corresponding to an <object> element that never loaded,
691             // we don't want to create a history item, because that causes fallback content
692             // to be ignored on reload.
693             
694             if (!(!hasChildLoaded && childLoader.isHostedByObjectElement()))
695                 bfItem->addChildItem(childLoader.history().createItemTree(targetFrame, clipAtTarget));
696         }
697     }
698     // FIXME: Eliminate the isTargetItem flag in favor of itemSequenceNumber.
699     if (&m_frame == &targetFrame)
700         bfItem->setIsTargetItem(true);
701     return bfItem;
702 }
703
704 // The general idea here is to traverse the frame tree and the item tree in parallel,
705 // tracking whether each frame already has the content the item requests.  If there is
706 // a match, we set the provisional item and recurse.  Otherwise we will reload that
707 // frame and all its kids in recursiveGoToItem.
708 void HistoryController::recursiveSetProvisionalItem(HistoryItem& item, HistoryItem* fromItem)
709 {
710     if (!itemsAreClones(item, fromItem))
711         return;
712
713     // Set provisional item, which will be committed in recursiveUpdateForCommit.
714     m_provisionalItem = &item;
715
716     for (auto& childItem : item.children()) {
717         const String& childFrameName = childItem->target();
718
719         HistoryItem* fromChildItem = fromItem->childItemWithTarget(childFrameName);
720         ASSERT(fromChildItem);
721         Frame* childFrame = m_frame.tree().child(childFrameName);
722         ASSERT(childFrame);
723
724         childFrame->loader().history().recursiveSetProvisionalItem(const_cast<HistoryItem&>(childItem.get()), fromChildItem);
725     }
726 }
727
728 // We now traverse the frame tree and item tree a second time, loading frames that
729 // do have the content the item requests.
730 void HistoryController::recursiveGoToItem(HistoryItem& item, HistoryItem* fromItem, FrameLoadType type)
731 {
732     if (!itemsAreClones(item, fromItem)) {
733         m_frame.loader().loadItem(item, type);
734         return;
735     }
736
737     // Just iterate over the rest, looking for frames to navigate.
738     for (auto& childItem : item.children()) {
739         const String& childFrameName = childItem->target();
740
741         HistoryItem* fromChildItem = fromItem->childItemWithTarget(childFrameName);
742         ASSERT(fromChildItem);
743         Frame* childFrame = m_frame.tree().child(childFrameName);
744         ASSERT(childFrame);
745         childFrame->loader().history().recursiveGoToItem(const_cast<HistoryItem&>(childItem.get()), fromChildItem, type);
746     }
747 }
748
749 bool HistoryController::itemsAreClones(HistoryItem& item1, HistoryItem* item2) const
750 {
751     // If the item we're going to is a clone of the item we're at, then we do
752     // not need to load it again.  The current frame tree and the frame tree
753     // snapshot in the item have to match.
754     // Note: Some clients treat a navigation to the current history item as
755     // a reload.  Thus, if item1 and item2 are the same, we need to create a
756     // new document and should not consider them clones.
757     // (See http://webkit.org/b/35532 for details.)
758     return item2
759         && &item1 != item2
760         && item1.itemSequenceNumber() == item2->itemSequenceNumber()
761         && currentFramesMatchItem(&item1)
762         && item2->hasSameFrames(item1);
763 }
764
765 // Helper method that determines whether the current frame tree matches given history item's.
766 bool HistoryController::currentFramesMatchItem(HistoryItem* item) const
767 {
768     if ((!m_frame.tree().uniqueName().isEmpty() || !item->target().isEmpty()) && m_frame.tree().uniqueName() != item->target())
769         return false;
770         
771     const HistoryItemVector& childItems = item->children();
772     if (childItems.size() != m_frame.tree().childCount())
773         return false;
774     
775     unsigned size = childItems.size();
776     for (unsigned i = 0; i < size; ++i) {
777         if (!m_frame.tree().child(childItems[i]->target()))
778             return false;
779     }
780     
781     return true;
782 }
783
784 void HistoryController::updateBackForwardListClippedAtTarget(bool doClip)
785 {
786     // In the case of saving state about a page with frames, we store a tree of items that mirrors the frame tree.  
787     // The item that was the target of the user's navigation is designated as the "targetItem".  
788     // When this function is called with doClip=true we're able to create the whole tree except for the target's children, 
789     // which will be loaded in the future. That part of the tree will be filled out as the child loads are committed.
790
791     Page* page = m_frame.page();
792     if (!page)
793         return;
794
795     if (m_frame.loader().documentLoader()->urlForHistory().isEmpty())
796         return;
797
798     FrameLoader& frameLoader = m_frame.mainFrame().loader();
799
800     Ref<HistoryItem> topItem = frameLoader.history().createItemTree(m_frame, doClip);
801     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());
802
803     page->backForward().addItem(WTF::move(topItem));
804 }
805
806 void HistoryController::updateCurrentItem()
807 {
808     if (!m_currentItem)
809         return;
810
811     DocumentLoader* documentLoader = m_frame.loader().documentLoader();
812
813     if (!documentLoader->unreachableURL().isEmpty())
814         return;
815
816     if (m_currentItem->url() != documentLoader->url()) {
817         // We ended up on a completely different URL this time, so the HistoryItem
818         // needs to be re-initialized.  Preserve the isTargetItem flag as it is a
819         // property of how this HistoryItem was originally created and is not
820         // dependent on the document.
821         bool isTargetItem = m_currentItem->isTargetItem();
822         m_currentItem->reset();
823         initializeItem(*m_currentItem);
824         m_currentItem->setIsTargetItem(isTargetItem);
825     } else {
826         // Even if the final URL didn't change, the form data may have changed.
827         m_currentItem->setFormInfoFromRequest(documentLoader->request());
828     }
829 }
830
831 void HistoryController::pushState(PassRefPtr<SerializedScriptValue> stateObject, const String& title, const String& urlString)
832 {
833     if (!m_currentItem)
834         return;
835
836     Page* page = m_frame.page();
837     ASSERT(page);
838
839     // Get a HistoryItem tree for the current frame tree.
840     Ref<HistoryItem> topItem = m_frame.mainFrame().loader().history().createItemTree(m_frame, false);
841     
842     // Override data in the current item (created by createItemTree) to reflect
843     // the pushState() arguments.
844     m_currentItem->setTitle(title);
845     m_currentItem->setStateObject(stateObject);
846     m_currentItem->setURLString(urlString);
847
848     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());
849
850     page->backForward().addItem(WTF::move(topItem));
851
852     if (m_frame.page()->usesEphemeralSession())
853         return;
854
855     addVisitedLink(*page, URL(ParsedURLString, urlString));
856     m_frame.loader().client().updateGlobalHistory();
857 }
858
859 void HistoryController::replaceState(PassRefPtr<SerializedScriptValue> stateObject, const String& title, const String& urlString)
860 {
861     if (!m_currentItem)
862         return;
863
864     LOG(History, "HistoryController %p replaceState: Setting url of current item %p to %s", this, m_currentItem.get(), urlString.ascii().data());
865
866     if (!urlString.isEmpty())
867         m_currentItem->setURLString(urlString);
868     m_currentItem->setTitle(title);
869     m_currentItem->setStateObject(stateObject);
870     m_currentItem->setFormData(0);
871     m_currentItem->setFormContentType(String());
872
873     if (m_frame.page()->usesEphemeralSession())
874         return;
875
876     ASSERT(m_frame.page());
877     addVisitedLink(*m_frame.page(), URL(ParsedURLString, urlString));
878     m_frame.loader().client().updateGlobalHistory();
879 }
880
881 void HistoryController::replaceCurrentItem(HistoryItem* item)
882 {
883     if (!item)
884         return;
885
886     m_previousItem = nullptr;
887     if (m_provisionalItem)
888         m_provisionalItem = item;
889     else
890         m_currentItem = item;
891 }
892
893 } // namespace WebCore