Add a unique frame id and save it on HistoryItem.

Source/core/frame/Frame.h

 /*
  * Copyright (C) 1998, 1999 Torben Weis <weis@kde.org>
  *                     1999-2001 Lars Knoll <knoll@kde.org>
  *                     1999-2001 Antti Koivisto <koivisto@kde.org>
  *                     2000-2001 Simon Hausmann <hausmann@kde.org>
  *                     2000-2001 Dirk Mueller <mueller@kde.org>
  *                     2000 Stefan Schimanski <1Stein@gmx.de>
  * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009, 2010 Apple Inc. All rights reserved.
  * Copyright (C) 2008 Nokia Corporation and/or its subsidiary(-ies)
  * Copyright (C) 2008 Eric Seidel <eric@webkit.org>
@@ skipping 50 matching lines @@
     class RenderPart;
     class RenderView;
     class TreeScope;
     class ScriptController;
     class Settings;
     class SpellChecker;
     class TreeScope;
     class VisiblePosition;
     class Widget;
 
+    class FrameInit : public RefCounted<FrameInit> {
+    public:
+        // For creating a dummy Frame
+        static PassRefPtr<FrameInit> create(int64_t frameID, Page* page, FrameLoaderClient* client)
+        {
+            return adoptRef(new FrameInit(frameID, page, client));
+        }
+
+        void setFrameLoaderClient(FrameLoaderClient* client) { m_client = client; }
+        FrameLoaderClient* frameLoaderClient() const { return m_client; }
+
+        int64_t frameID() const { return m_frameID; }
+
+        void setPage(Page* page) { m_page = page; }
+        Page* page() const { return m_page; }
+
+        void setOwnerElement(HTMLFrameOwnerElement* ownerElement) { m_ownerElement = ownerElement; }
+        HTMLFrameOwnerElement* ownerElement() const { return m_ownerElement; }
+
+    protected:
+        FrameInit(int64_t frameID, Page* page = 0, FrameLoaderClient* client = 0)
+            : m_frameID(frameID)
+            , m_client(client)
+            , m_page(page)
+            , m_ownerElement(0)
+        {
+        }
+
+    private:
+        int64_t m_frameID;
+        FrameLoaderClient* m_client;
+        Page* m_page;
+        HTMLFrameOwnerElement* m_ownerElement;
+    };
+
     class Frame : public RefCounted<Frame> {
     public:
-        static PassRefPtr<Frame> create(Page*, HTMLFrameOwnerElement*, FrameLoaderClient*);
+        static PassRefPtr<Frame> create(PassRefPtr<FrameInit>);
 
         void init();
         void setView(PassRefPtr<FrameView>);
         void createView(const IntSize&, const Color&, bool,
             ScrollbarMode = ScrollbarAuto, bool horizontalLock = false,
             ScrollbarMode = ScrollbarAuto, bool verticalLock = false);
 
         ~Frame();
 
         void addDestructionObserver(FrameDestructionObserver*);
@@ skipping 21 matching lines @@
         InputMethodController& inputMethodController() const;
         FetchContext& fetchContext() const { return loader().fetchContext(); }
         ScriptController& script();
         SpellChecker& spellChecker() const;
 
         RenderView* contentRenderer() const; // Root of the render tree for the document contained in this frame.
         RenderPart* ownerRenderer() const; // Renderer for the element that contains this frame.
 
         void dispatchVisibilityStateChangeEvent();
 
+        int64_t frameID() const { return m_frameInit->frameID(); }
+
     // ======== All public functions below this point are candidates to move out of Frame into another class. ========
 
         bool inScope(TreeScope*) const;
 
         // See GraphicsLayerClient.h for accepted flags.
         String layerTreeAsText(unsigned flags = 0) const;
         String trackedRepaintRectsAsText() const;
 
         Settings* settings() const; // can be NULL
 
@@ skipping 34 matching lines @@
         PassRefPtr<Range> rangeForPoint(const IntPoint& framePoint);
 
         // Should only be called on the main frame of a page.
         void notifyChromeClientWheelEventHandlerCountChanged() const;
 
         bool isURLAllowed(const KURL&) const;
 
     // ========
 
     private:
-        Frame(Page*, HTMLFrameOwnerElement*, FrameLoaderClient*);
+        Frame(PassRefPtr<FrameInit>);
 
         HashSet<FrameDestructionObserver*> m_destructionObservers;
 
         Page* m_page;
         mutable FrameTree m_treeNode;
         mutable FrameLoader m_loader;
         mutable NavigationScheduler m_navigationScheduler;
 
-        HTMLFrameOwnerElement* m_ownerElement;
         RefPtr<FrameView> m_view;
         RefPtr<DOMWindow> m_domWindow;
 
         OwnPtr<ScriptController> m_script;
         const OwnPtr<Editor> m_editor;
         const OwnPtr<SpellChecker> m_spellChecker;
         const OwnPtr<FrameSelection> m_selection;
         const OwnPtr<EventHandler> m_eventHandler;
         OwnPtr<AnimationController> m_animationController;
         OwnPtr<InputMethodController> m_inputMethodController;
 
+        RefPtr<FrameInit> m_frameInit;
+
         float m_pageZoomFactor;
         float m_textZoomFactor;
 
 #if ENABLE(ORIENTATION_EVENTS)
         int m_orientation;
 #endif
 
         bool m_inViewSourceMode;
     };
 
@@ skipping 47 matching lines @@
         return *m_animationController;
     }
 
     inline InputMethodController& Frame::inputMethodController() const
     {
         return *m_inputMethodController;
     }
 
     inline HTMLFrameOwnerElement* Frame::ownerElement() const
     {
-        return m_ownerElement;
+        return m_frameInit->ownerElement();
     }
 
     inline bool Frame::inViewSourceMode() const
     {
         return m_inViewSourceMode;
     }
 
     inline void Frame::setInViewSourceMode(bool mode)
     {
         m_inViewSourceMode = mode;
@@ skipping 11 matching lines @@
 
     inline EventHandler& Frame::eventHandler() const
     {
         ASSERT(m_eventHandler);
         return *m_eventHandler;
     }
 
 } // namespace WebCore
 
 #endif // Frame_h