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