Split the frame tree logic out of HistoryItem

Source/core/loader/HistoryController.h

 /*
  * Copyright (C) 2006, 2007, 2008, 2009 Apple Inc. All rights reserved.
  * Copyright (C) 2008, 2009 Torch Mobile Inc. All rights reserved. (http://www.torchmobile.com/)
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  *
  * 1.  Redistributions of source code must retain the above copyright
  *     notice, this list of conditions and the following disclaimer.
@@ skipping 14 matching lines @@
  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #ifndef HistoryController_h
 #define HistoryController_h
 
 #include "core/history/HistoryItem.h"
 #include "core/loader/FrameLoaderTypes.h"
+#include "wtf/HashMap.h"
 #include "wtf/Noncopyable.h"
 #include "wtf/RefPtr.h"
 #include "wtf/text/WTFString.h"
 
 namespace WebCore {
 
 class Frame;
+class HistoryEntry;
+class Page;
 class SerializedScriptValue;
 
+
+class HistoryEntryItem {

[abarth-chromium, 2013/11/13 19:15:37]

HistoryNode?

[Nate Chapin, 2013/11/13 19:30:39]

Yeah, that's a better name. Will change it.

+public:
+    static PassOwnPtr<HistoryEntryItem> create(HistoryEntry*, HistoryItem*);
+    ~HistoryEntryItem() { }
+
+    HistoryEntryItem* addChild(PassRefPtr<HistoryItem>);
+    PassOwnPtr<HistoryEntryItem> cloneAndReplace(HistoryEntry*, HistoryItem* newItem, HistoryItem* oldItem, bool clipAtTarget, Frame*);
+    HistoryItem* value() { return m_value.get(); }
+    void updateValue(PassRefPtr<HistoryItem> item) { m_value = item; }
+    const Vector<OwnPtr<HistoryEntryItem> >& children() const { return m_children; }
+
+private:
+    HistoryEntryItem(HistoryEntry*, HistoryItem*);
+
+    HistoryEntry* m_entry;
+    Vector<OwnPtr<HistoryEntryItem> > m_children;
+    RefPtr<HistoryItem> m_value;
+};
+
+class HistoryEntry {
+public:
+    static PassOwnPtr<HistoryEntry> create(HistoryItem* root);
+    PassOwnPtr<HistoryEntry> cloneAndReplace(HistoryItem* newItem, HistoryItem* oldItem, bool clipAtTarget, Page*);
+
+    HistoryEntryItem* entryForFrame(Frame*);

[abarth-chromium, 2013/11/13 19:15:37]

It's awkward that this returns a HistoryEntryItem rather than an HistoryEntry
given the name of the function.  If you rename HistoryEntryItem to HistoryNode,
consider renaming this function to historyNodeForFrame.

[Nate Chapin, 2013/11/13 19:30:39]

Will do.

+    HistoryItem* itemForFrame(Frame*);
+    HistoryItem* root() const { return m_root->value(); }
+    HistoryEntryItem* rootEntry() const { return m_root.get(); }

[abarth-chromium, 2013/11/13 19:15:37]

Same comment here w/ rootNode

[Nate Chapin, 2013/11/13 19:30:39]

Will do.

+
+private:
+    friend class HistoryEntryItem;
+
+    HistoryEntry() { }
+    explicit HistoryEntry(HistoryItem* root);
+
+    OwnPtr<HistoryEntryItem> m_root;
+    HashMap<uint64_t, HistoryEntryItem*> m_framesToItems;
+    HashMap<String, HistoryEntryItem*> m_uniqueNamesToItems;

[abarth-chromium, 2013/11/13 19:15:37]

It's unfortunate that we need both these maps...  Is there a future for this
code in which we could get down to one map?

[Nate Chapin, 2013/11/13 19:30:39]

Yeah, it's lame, and I'm not sure there's a way around it. You need the
names->items mapping to handle the back/forward case where the frame doesn't
exist yet, and you need some way to make the system resilient to the frame name
(and therefore the uniqueName) changing, so you either need to index all current
and former names, or have something that doesn't change when the name changes
(the frameid->item mapping). This seemed the least terrible and most stable
option I could think of, but I don't immediately see how to fix it.

+};
+
 class HistoryController {
     WTF_MAKE_NONCOPYABLE(HistoryController);
 public:
-    explicit HistoryController(Frame*);
+    explicit HistoryController(Page*);
     ~HistoryController();
 
+    // Should only be called by embedder. To request a back/forward
+    // navigation, call FrameLoaderClient::navigateBackForward().
+    void goToItem(HistoryItem*);
+
     void clearScrollPositionAndViewState();
-    void restoreScrollPositionAndViewState();
+    void restoreScrollPositionAndViewState(Frame*);
 
-    void updateBackForwardListForFragmentScroll();
+    void updateBackForwardListForFragmentScroll(Frame*);
 
-    void saveDocumentAndScrollState();
-    void restoreDocumentState();
+    void saveDocumentAndScrollState(Frame*);
+    void restoreDocumentState(Frame*);
 
-    void updateForCommit();
-    void updateForSameDocumentNavigation();
+    void updateForCommit(Frame*);
+    void updateForSameDocumentNavigation(Frame*);
 
-    HistoryItem* currentItem() const { return m_currentItem.get(); }
-    void setCurrentItem(HistoryItem*);
-    bool currentItemShouldBeReplaced() const;
+    PassRefPtr<HistoryItem> currentItemForExport(Frame*);
+    PassRefPtr<HistoryItem> previousItemForExport(Frame*);
+    PassRefPtr<HistoryItem> provisionalItemForExport(Frame*);
 
-    HistoryItem* previousItem() const { return m_previousItem.get(); }
+    HistoryItem* currentItem(Frame*) const;
+    bool currentItemShouldBeReplaced(Frame*) const;
 
-    HistoryItem* provisionalItem() const { return m_provisionalItem.get(); }
-    void setProvisionalItem(HistoryItem*);
+    HistoryItem* previousItem(Frame*) const;
+    void clearProvisionalEntry();
 
-    void pushState(PassRefPtr<SerializedScriptValue>, const String& url);
-    void replaceState(PassRefPtr<SerializedScriptValue>, const String& url);
+    bool inSameDocumentLoad() const { return !m_sameDocumentLoadsInProgress.isEmpty() && m_differentDocumentLoadsInProgress.isEmpty(); }
+
+    void pushState(Frame*, PassRefPtr<SerializedScriptValue>, const String& url);
+    void replaceState(Frame*, PassRefPtr<SerializedScriptValue>, const String& url);
 
     void setDefersLoading(bool);
 
 private:
-    friend class Page;
-    bool shouldStopLoadingForHistoryItem(HistoryItem*) const;
-    void goToItem(HistoryItem*);
+    void goToEntry(PassOwnPtr<HistoryEntry>);
+    void recursiveGoToEntry(Frame*);
 
-    void initializeItem(HistoryItem*);
-    PassRefPtr<HistoryItem> createItem();
-    PassRefPtr<HistoryItem> createItemTree(Frame* targetFrame, bool clipAtTarget);
+    void initializeItem(HistoryItem*, Frame*);
+    PassRefPtr<HistoryItem> createItem(Frame*);
+    HistoryItem* createItemTree(Frame* targetFrame, bool clipAtTarget);
 
-    void updateForStandardLoad();
-    void updateForInitialLoadInChildFrame();
+    void updateForStandardLoad(Frame*);
+    void updateForInitialLoadInChildFrame(Frame*);
 
-    void recursiveSetProvisionalItem(HistoryItem*, HistoryItem*);
-    void recursiveGoToItem(HistoryItem*, HistoryItem*);
-    void recursiveUpdateForCommit();
-    void recursiveUpdateForSameDocumentNavigation();
-    bool itemsAreClones(HistoryItem*, HistoryItem*) const;
-    bool currentFramesMatchItem(HistoryItem*) const;
+    void createNewBackForwardItem(Frame*, bool doClip);
+    void updateWithoutCreatingNewBackForwardItem(Frame*);
 
-    void createNewBackForwardItem(bool doClip);
-    void updateWithoutCreatingNewBackForwardItem();
+    Page* m_page;
 
-    void clearProvisionalItemsInAllFrames();
+    OwnPtr<HistoryEntry> m_currentEntry;
+    OwnPtr<HistoryEntry> m_previousEntry;
+    OwnPtr<HistoryEntry> m_provisionalEntry;
 
-    Frame* m_frame;
-
-    RefPtr<HistoryItem> m_currentItem;
-    RefPtr<HistoryItem> m_previousItem;
-    RefPtr<HistoryItem> m_provisionalItem;
+    typedef HashMap<Frame*, HistoryItem*> HistoryFrameLoadSet;
+    HistoryFrameLoadSet m_sameDocumentLoadsInProgress;
+    HistoryFrameLoadSet m_differentDocumentLoadsInProgress;
 
     bool m_defersLoading;
     RefPtr<HistoryItem> m_deferredItem;
 };
 
 } // namespace WebCore
 
 #endif // HistoryController_h