DRAFT CL: Add FrameNavigationEntry and track subframe session histories.

content/browser/frame_host/navigation_controller_impl.h

 // Copyright 2013 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #ifndef CONTENT_BROWSER_FRAME_HOST_NAVIGATION_CONTROLLER_IMPL_H_
 #define CONTENT_BROWSER_FRAME_HOST_NAVIGATION_CONTROLLER_IMPL_H_
 
 #include "base/callback.h"
 #include "base/compiler_specific.h"
 #include "base/gtest_prod_util.h"
 #include "base/memory/linked_ptr.h"
 #include "base/time/time.h"
 #include "build/build_config.h"
 #include "content/browser/frame_host/navigation_controller_delegate.h"
 #include "content/browser/frame_host/navigation_entry_impl.h"
 #include "content/browser/ssl/ssl_manager.h"
 #include "content/public/browser/navigation_controller.h"
 #include "content/public/browser/navigation_type.h"
 
 struct FrameHostMsg_DidCommitProvisionalLoad_Params;
 
 namespace content {
+class FrameTreeNode;
 class RenderFrameHostImpl;
 class NavigationEntryScreenshotManager;
 class SiteInstance;
 struct LoadCommittedDetails;
 
 class CONTENT_EXPORT NavigationControllerImpl
     : public NON_EXPORTED_BASE(NavigationController) {
  public:
   NavigationControllerImpl(
       NavigationControllerDelegate* delegate,
@@ skipping 62 matching lines @@
 
   // The session storage namespace that all child RenderViews belonging to
   // |instance| should use.
   SessionStorageNamespace* GetSessionStorageNamespace(
       SiteInstance* instance);
 
   // Returns the index of the specified entry, or -1 if entry is not contained
   // in this NavigationController.
   int GetIndexOfEntry(const NavigationEntryImpl* entry) const;
 
-  // Return the index of the entry with the corresponding instance and page_id,
-  // or -1 if not found.
-  int GetEntryIndexWithPageID(SiteInstance* instance,
-                              int32 page_id) const;
+  // Return the index of the entry with the corresponding page_id, or -1 if not
+  // found.
+  int GetEntryIndexWithPageID(int32 page_id) const;
 
-  // Return the entry with the corresponding instance and page_id, or NULL if
-  // not found.
-  NavigationEntryImpl* GetEntryWithPageID(
-      SiteInstance* instance,
-      int32 page_id) const;
+  // TODO(creis): Private?  const?
+  int GetFrameEntryIndex(int64 frame_tree_node_id,
+                         SiteInstance* site_instance,
+                         int64 item_sequence_number);
+
+  // Return the entry with the corresponding page_id, or NULL if not found.
+  NavigationEntryImpl* GetEntryWithPageID(int32 page_id) const;
 
   NavigationControllerDelegate* delegate() const {
     return delegate_;
   }
 
   // For use by WebContentsImpl ------------------------------------------------
 
   // Allow renderer-initiated navigations to create a pending entry when the
   // provisional load starts.
   void SetPendingEntry(content::NavigationEntryImpl* entry);
@@ skipping 80 matching lines @@
  private:
   friend class RestoreHelper;
 
   FRIEND_TEST_ALL_PREFIXES(NavigationControllerTest,
                            PurgeScreenshot);
   FRIEND_TEST_ALL_PREFIXES(TimeSmoother, Basic);
   FRIEND_TEST_ALL_PREFIXES(TimeSmoother, SingleDuplicate);
   FRIEND_TEST_ALL_PREFIXES(TimeSmoother, ManyDuplicates);
   FRIEND_TEST_ALL_PREFIXES(TimeSmoother, ClockBackwardsJump);
 
+  typedef std::vector<std::pair<FrameTreeNode*, FrameNavigationEntry*> >
+      FrameLoadVector;
+
   // Helper class to smooth out runs of duplicate timestamps while still
   // allowing time to jump backwards.
   class CONTENT_EXPORT TimeSmoother {
    public:
     // Returns |t| with possibly some time added on.
     base::Time GetSmoothedTime(base::Time t);
 
    private:
     // |low_water_mark_| is the first time in a sequence of adjusted
     // times and |high_water_mark_| is the last.
     base::Time low_water_mark_;
     base::Time high_water_mark_;
   };
 
+  // TODO(creis): Remove and share code with CreateNavigationEntry.
+  NavigationEntryImpl* CreateSubframeNavigationEntry(
+      int64 frame_tree_node_id,
+      const GURL& url,
+      const Referrer& referrer,
+      ui::PageTransition transition,
+      bool is_renderer_initiated,
+      const std::string& extra_headers,
+      BrowserContext* browser_context);
+
   // Classifies the given renderer navigation (see the NavigationType enum).
   NavigationType ClassifyNavigation(
       RenderFrameHostImpl* rfh,
       const FrameHostMsg_DidCommitProvisionalLoad_Params& params) const;
 
   // Causes the controller to load the specified entry. The function assumes
   // ownership of the pointer since it is put in the navigation list.
   // NOTE: Do not pass an entry that the controller already owns!
   void LoadEntry(NavigationEntryImpl* entry);
 
@@ skipping 45 matching lines @@
   void UpdateVirtualURLToURL(NavigationEntryImpl* entry,
                              const GURL& new_url);
 
   // Invoked after session/tab restore or cloning a tab. Resets the transition
   // type of the entries, updates the max page id and creates the active
   // contents.
   void FinishRestore(int selected_index, RestoreType type);
 
   // Inserts a new entry or replaces the current entry with a new one, removing
   // all entries after it. The new entry will become the active one.
-  void InsertOrReplaceEntry(NavigationEntryImpl* entry, bool replace);
+  void InsertOrReplaceEntry(RenderFrameHostImpl* render_frame_host,
+                            NavigationEntryImpl* entry,
+                            FrameNavigationEntry* frame_entry,
+                            bool replace);
 
   // Removes the entry at |index|, as long as it is not the current entry.
   void RemoveEntryAtIndexInternal(int index);
 
   // Discards both the pending and transient entries.
   void DiscardNonCommittedEntriesInternal();
 
   // Discards only the transient entry.
   void DiscardTransientEntry();
 
@@ skipping 15 matching lines @@
   // Inserts up to |max_index| entries from |source| into this. This does NOT
   // adjust any of the members that reference entries_
   // (last_committed_entry_index_, pending_entry_index_ or
   // transient_entry_index_).
   void InsertEntriesFrom(const NavigationControllerImpl& source, int max_index);
 
   // Returns the navigation index that differs from the current entry by the
   // specified |offset|.  The index returned is not guaranteed to be valid.
   int GetIndexForOffset(int offset) const;
 
+  // Recursively add FrameNavigationEntry pointers for the current entries in
+  // each frame's session history to the tree in the top-level NavigationEntry.
+  void AddFramesToNavigationEntry(
+    NavigationEntryImpl::TreeNode* entry_node,
+    FrameTreeNode* frame_tree_node);
+
+  // Recursively identifies which frames need to be navigated for the pending
+  // NavigationEntry, then tells each such frame to navigate.
+  bool NavigateToPendingEntryInternal(ReloadType reload_type);
+  void RecursiveNavigateToPendingEntry(FrameTreeNode* frame,
+                                       FrameLoadVector* sameDocumentLoads,
+                                       FrameLoadVector* differentDocumentLoads);
+
   // ---------------------------------------------------------------------------
 
   // The user browser context associated with this controller.
   BrowserContext* browser_context_;
 
   // List of NavigationEntry for this tab
   typedef std::vector<linked_ptr<NavigationEntryImpl> > NavigationEntries;
   NavigationEntries entries_;
 
   // An entry we haven't gotten a response for yet.  This will be discarded
@@ skipping 16 matching lines @@
   // used for interstitial pages. -1 if there are no such entry.
   // Note that this entry really appears in the list of entries, but only
   // temporarily (until the next navigation).  Any index pointing to an entry
   // after the transient entry will become invalid if you navigate forward.
   int transient_entry_index_;
 
   // The delegate associated with the controller. Possibly NULL during
   // setup.
   NavigationControllerDelegate* delegate_;
 
+  // The next available page ID, which identifies joint session history items.
+  // TODO(creis): Copy when cloning tabs.
+  int32 next_page_id_;
+
   // The max restored page ID in this controller, if it was restored.  We must
   // store this so that WebContentsImpl can tell any renderer in charge of one
   // of the restored entries to update its max page ID.
   int32 max_restored_page_id_;
 
   // Manages the SSL security UI.
   SSLManager ssl_manager_;
 
   // Whether we need to be reloaded when made active.
   bool needs_reload_;
@@ skipping 32 matching lines @@
   TimeSmoother time_smoother_;
 
   scoped_ptr<NavigationEntryScreenshotManager> screenshot_manager_;
 
   DISALLOW_COPY_AND_ASSIGN(NavigationControllerImpl);
 };
 
 }  // namespace content
 
 #endif  // CONTENT_BROWSER_FRAME_HOST_NAVIGATION_CONTROLLER_IMPL_H_