Move a bunch of TabContents related files into a tab_contents subdir

Review URL: http://codereview.chromium.org/18250

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@8058 0039d316-1c4b-4281-b951-d872f2087c98

1 files changed, 550 insertions, 0 deletions

diff --git a/chrome/browser/tab_contents/navigation_controller.h b/chrome/browser/tab_contents/navigation_controller.h
new file mode 100644
index 0000000..dac0a37
--- /dev/null
+++ b/chrome/browser/tab_contents/navigation_controller.h
@@ -0,0 +1,550 @@
+// Copyright (c) 2006-2008 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 CHROME_BROWSER_NAVIGATION_CONTROLLER_H_
+#define CHROME_BROWSER_NAVIGATION_CONTROLLER_H_
+
+#include <map>
+
+#include "base/linked_ptr.h"
+#include "base/ref_counted.h"
+#include "chrome/browser/sessions/session_id.h"
+#include "chrome/browser/ssl_manager.h"
+#include "chrome/browser/tab_contents/site_instance.h"
+#include "chrome/browser/tab_contents/tab_contents_type.h"
+#include "chrome/common/navigation_types.h"
+
+class GURL;
+class Profile;
+class TabContents;
+class WebContents;
+class TabContentsCollector;
+class TabNavigation;
+struct ViewHostMsg_FrameNavigate_Params;
+
+// A NavigationController maintains the back-forward list for a single tab and
+// manages all navigation within that list.
+//
+// The NavigationController also owns all TabContents for the tab. This is to
+// make sure that we have at most one TabContents instance per type.
+class NavigationController {
+ public:
+  // Notification details ------------------------------------------------------
+
+  // Provides the details for a NOTIFY_NAV_ENTRY_CHANGED notification.
+  struct EntryChangedDetails {
+    // The changed navigation entry after it has been updated.
+    const NavigationEntry* changed_entry;
+
+    // Indicates the current index in the back/forward list of the entry.
+    int index;
+  };
+
+  // Provides the details for a NOTIFY_NAV_ENTRY_COMMITTED notification.
+  // TODO(brettw) this mostly duplicates ProvisionalLoadDetails, it would be
+  // nice to unify these somehow.
+  struct LoadCommittedDetails {
+    // By default, the entry will be filled according to a new main frame
+    // navigation.
+    LoadCommittedDetails()
+        : entry(NULL),
+          is_auto(false),
+          is_in_page(false),
+          is_main_frame(true) {
+    }
+
+    // The committed entry. This will be the active entry in the controller.
+    NavigationEntry* entry;
+
+    // The type of navigation that just occurred. Note that not all types of
+    // navigations in the enum are valid here, since some of them don't actually
+    // cause a "commit" and won't generate this notification.
+    NavigationType::Type type;
+
+    // The index of the previously committed navigation entry. This will be -1
+    // if there are no previous entries.
+    int previous_entry_index;
+
+    // The previous URL that the user was on. This may be empty if none.
+    GURL previous_url;
+
+    // True when this load was non-user initated. This corresponds to a
+    // a NavigationGestureAuto call from WebKit (see webview_delegate.h).
+    // We also count reloads and meta-refreshes as "auto" to account for the
+    // fact that WebKit doesn't always set the user gesture properly in these
+    // cases (see bug 1051891).
+    bool is_auto;
+
+    // True if the navigation was in-page. This means that the active entry's
+    // URL and the |previous_url| are the same except for reference fragments.
+    bool is_in_page;
+
+    // True when the main frame was navigated. False means the navigation was a
+    // sub-frame.
+    bool is_main_frame;
+
+    // Whether the content of this frame has been altered/blocked because it was
+    // unsafe.
+    bool is_content_filtered;
+
+    // When the committed load is a web page from the renderer, this string
+    // specifies the security state if the page is secure.
+    // See ViewHostMsg_FrameNavigate_Params.security_info, where it comes from.
+    // Use SSLManager::DeserializeSecurityInfo to decode it.
+    std::string serialized_security_info;
+
+    // Returns whether the user probably felt like they navigated somewhere new.
+    // We often need this logic for showing or hiding something, and this
+    // returns true only for main frame loads that the user initiated, that go
+    // to a new page.
+    bool is_user_initiated_main_frame_load() const {
+      return !is_auto && !is_in_page && is_main_frame;
+    }
+  };
+
+  // Details sent for NOTIFY_NAV_LIST_PRUNED.
+  struct PrunedDetails {
+    // If true, count items were removed from the front of the list, otherwise
+    // count items were removed from the back of the list.
+    bool from_front;
+
+    // Number of items removed.
+    int count;
+  };
+
+  // ---------------------------------------------------------------------------
+
+  NavigationController(TabContents* initial_contents, Profile* profile);
+
+  // Creates a NavigationController from the specified history. Processing
+  // for this is asynchronous and handled via the RestoreHelper (in
+  // navigation_controller.cc).
+  NavigationController(
+      Profile* profile,
+      const std::vector<TabNavigation>& navigations,
+      int selected_navigation);
+  ~NavigationController();
+
+  // Begin the destruction sequence for this NavigationController and all its
+  // registered tabs.  The sequence is as follows:
+  // 1. All tabs are asked to Destroy themselves.
+  // 2. When each tab is finished Destroying, it will notify the controller.
+  // 3. Once all tabs are Destroyed, the NavigationController deletes itself.
+  // This ensures that all the TabContents outlive the NavigationController.
+  void Destroy();
+
+  // Clone the receiving navigation controller. Only the active tab contents is
+  // duplicated.
+  NavigationController* Clone();
+
+  // Returns the profile for this controller. It can never be NULL.
+  Profile* profile() const {
+    return profile_;
+  }
+
+  // Active entry --------------------------------------------------------------
+
+  // Returns the active entry, which is the transient entry if any, the pending
+  // entry if a navigation is in progress or the last committed entry otherwise.
+  // NOTE: This can be NULL!!
+  //
+  // If you are trying to get the current state of the NavigationController,
+  // this is the method you will typically want to call.
+  //
+  NavigationEntry* GetActiveEntry() const;
+
+  // Returns the index from which we would go back/forward or reload.  This is
+  // the last_committed_entry_index_ if pending_entry_index_ is -1.  Otherwise,
+  // it is the pending_entry_index_.
+  int GetCurrentEntryIndex() const;
+
+  // Returns the last committed entry, which may be null if there are no
+  // committed entries.
+  NavigationEntry* GetLastCommittedEntry() const;
+
+  // Returns the index of the last committed entry.
+  int GetLastCommittedEntryIndex() const {
+    return last_committed_entry_index_;
+  }
+
+  // Navigation list -----------------------------------------------------------
+
+  // Returns the number of entries in the NavigationController, excluding
+  // the pending entry if there is one, but including the transient entry if
+  // any.
+  int GetEntryCount() const {
+    return static_cast<int>(entries_.size());
+  }
+
+  NavigationEntry* GetEntryAtIndex(int index) const {
+    return entries_.at(index).get();
+  }
+
+  // Returns the entry at the specified offset from current.  Returns NULL
+  // if out of bounds.
+  NavigationEntry* GetEntryAtOffset(int offset) const;
+
+  // Returns the index of the specified entry, or -1 if entry is not contained
+  // in this NavigationController.
+  int GetIndexOfEntry(const NavigationEntry* entry) const;
+
+  // Return the index of the entry with the corresponding type, instance, and
+  // page_id, or -1 if not found.  Use a NULL instance if the type is not
+  // TAB_CONTENTS_WEB.
+  int GetEntryIndexWithPageID(TabContentsType type,
+                              SiteInstance* instance,
+                              int32 page_id) const;
+
+  // Return the entry with the corresponding type, instance, and page_id, or
+  // NULL if not found.  Use a NULL instance if the type is not
+  // TAB_CONTENTS_WEB.
+  NavigationEntry* GetEntryWithPageID(TabContentsType type,
+                                      SiteInstance* instance,
+                                      int32 page_id) const;
+
+  // Pending entry -------------------------------------------------------------
+
+  // Commits the current pending entry and issues the NOTIFY_NAV_ENTRY_COMMIT
+  // notification. No changes are made to the entry during this process, it is
+  // just moved from pending to committed. This is an alternative to
+  // RendererDidNavigate for simple TabContents types.
+  //
+  // When the pending entry is a new navigation, it will have a page ID of -1.
+  // The caller should leave this as-is. CommitPendingEntry will generate a
+  // new page ID for you and update the TabContents with that ID.
+  void CommitPendingEntry();
+
+  // Discards the pending and transient entries if any.  Calling this may cause
+  // the active tab contents to switch if the current entry corresponds to a
+  // different tab contents type.
+  void DiscardNonCommittedEntries();
+
+  // Returns the pending entry corresponding to the navigation that is
+  // currently in progress, or null if there is none.
+  NavigationEntry* GetPendingEntry() const {
+    return pending_entry_;
+  }
+
+  // Returns the index of the pending entry or -1 if the pending entry
+  // corresponds to a new navigation (created via LoadURL).
+  int GetPendingEntryIndex() const {
+    return pending_entry_index_;
+  }
+
+  // Transient entry -----------------------------------------------------------
+
+  // Adds an entry that is returned by GetActiveEntry().  The entry is
+  // transient: any navigation causes it to be removed and discarded.
+  // The NavigationController becomes the owner of |entry| and deletes it when
+  // it discards it.  This is useful with interstitial page that need to be
+  // represented as an entry, but should go away when the user navigates away
+  // from them.
+  // Note that adding a transient entry does not change the active contents.
+  void AddTransientEntry(NavigationEntry* entry);
+
+  // Returns the transient entry if any.  Note that the returned entry is owned
+  // by the navigation controller and may be deleted at any time.
+  NavigationEntry* GetTransientEntry() const;
+
+  // New navigations -----------------------------------------------------------
+
+  // Loads the specified URL.
+  void LoadURL(const GURL& url, const GURL& referrer,
+               PageTransition::Type type);
+
+  // Load the specified URL the next time it becomes active.
+  void LoadURLLazily(const GURL& url, const GURL& referrer,
+                     PageTransition::Type type, const std::wstring& title,
+                     SkBitmap* icon);
+
+  // Loads the current page if this NavigationController was restored from
+  // history and the current page has not loaded yet.
+  void LoadIfNecessary();
+
+  // Renavigation --------------------------------------------------------------
+
+  // Navigation relative to the "current entry"
+  bool CanGoBack() const;
+  bool CanGoForward() const;
+  void GoBack();
+  void GoForward();
+
+  // Navigates to the specified absolute index.
+  void GoToIndex(int index);
+
+  // Navigates to the specified offset from the "current entry". Does nothing if
+  // the offset is out of bounds.
+  void GoToOffset(int offset);
+
+  // Reloads the current entry. If |check_for_repost| is true and the current
+  // entry has POST data the user is prompted to see if they really want to
+  // reload the page. In nearly all cases pass in true.
+  void Reload(bool check_for_repost);
+
+  // Removing of entries -------------------------------------------------------
+
+  // Removes the entry at the specified |index|.  This call dicards any pending
+  // and transient entries.  |default_url| is the URL that the navigation
+  // controller navigates to if there are no more entries after the removal.
+  // If |default_url| is empty, we default to "about:blank".
+  void RemoveEntryAtIndex(int index, const GURL& default_url);
+
+  // TabContents ---------------------------------------------------------------
+
+  // Notifies the controller that a TabContents that it owns has been destroyed.
+  // This is part of the NavigationController's Destroy sequence.
+  void TabContentsWasDestroyed(TabContentsType type);
+
+  // Returns the TabContents cached on this controller for the given type or
+  // NULL if there is none.
+  TabContents* GetTabContents(TabContentsType type);
+
+  // Returns the currently-active TabContents associated with this controller.
+  // You should use GetActiveEntry instead of this in most cases.
+  TabContents* active_contents() const {
+    return active_contents_;
+  }
+
+  // For use by TabContents ----------------------------------------------------
+
+  // Handles updating the navigation state after the renderer has navigated.
+  // This is used by the WebContents. Simpler tab contents types can use
+  // CommitPendingEntry below.
+  //
+  // If a new entry is created, it will return true and will have filled the
+  // given details structure and broadcast the NOTIFY_NAV_ENTRY_COMMITTED
+  // notification. The caller can then use the details without worrying about
+  // listening for the notification.
+  //
+  // In the case that nothing has changed, the details structure is undefined
+  // and it will return false.
+  bool RendererDidNavigate(const ViewHostMsg_FrameNavigate_Params& params,
+                           LoadCommittedDetails* details);
+
+  // Notifies us that we just became active. This is used by the TabContents
+  // so that we know to load URLs that were pending as "lazy" loads.
+  void SetActive(bool is_active);
+
+  // Broadcasts the NOTIFY_NAV_ENTRY_CHANGED notification for the given entry
+  // (which must be at the given index). This will keep things in sync like
+  // the saved session.
+  void NotifyEntryChanged(const NavigationEntry* entry, int index);
+
+  // Returns true if the given URL would be an in-page navigation (i.e. only
+  // the reference fragment is different) from the "last committed entry". We do
+  // not compare it against the "active entry" since the active entry can be
+  // pending and in page navigations only happen on committed pages. If there
+  // is no last committed entry, then nothing will be in-page.
+  //
+  // Special note: if the URLs are the same, it does NOT count as an in-page
+  // navigation. Neither does an input URL that has no ref, even if the rest is
+  // the same. This may seem weird, but when we're considering whether a
+  // navigation happened without loading anything, the same URL would be a
+  // reload, while only a different ref would be in-page (pages can't clear
+  // refs without reload, only change to "#" which we don't count as empty).
+  bool IsURLInPageNavigation(const GURL& url) const;
+
+  // Random data ---------------------------------------------------------------
+
+  // Returns true if this NavigationController is is configured to load a URL
+  // lazily. If true, use GetLazyTitle() and GetLazyFavIcon() to discover the
+  // titles and favicons. Since no request was made, this is the only info
+  // we have about this page. This feature is used by web application clusters.
+  bool LoadingURLLazily();
+  const std::wstring& GetLazyTitle() const;
+  const SkBitmap& GetLazyFavIcon() const;
+
+  // Returns the identifier used by session restore.
+  const SessionID& session_id() const { return session_id_; }
+
+  // Identifier of the window we're in.
+  void SetWindowID(const SessionID& id);
+  const SessionID& window_id() const { return window_id_; }
+
+  SSLManager* ssl_manager() { return &ssl_manager_; }
+
+  // Returns true if a reload happens when activated (SetActive(true) is
+  // invoked). This is true for session/tab restore and cloned tabs.
+  bool needs_reload() const { return needs_reload_; }
+
+  // Returns the largest restored page ID seen in this navigation controller,
+  // if it was restored from a previous session.  (-1 otherwise)
+  int max_restored_page_id() const { return max_restored_page_id_; }
+
+  // Disables checking for a repost and prompting the user. This is used during
+  // testing.
+  static void DisablePromptOnRepost();
+
+  // Maximum number of entries before we start removing entries from the front.
+  static void set_max_entry_count(size_t max_entry_count) {
+    max_entry_count_ = max_entry_count;
+  }
+  static size_t max_entry_count() { return max_entry_count_; }
+
+ private:
+  class RestoreHelper;
+  friend class RestoreHelper;
+  friend class TabContents;  // For invoking OnReservedPageIDRange.
+
+  // Classifies the given renderer navigation (see the NavigationType enum).
+  NavigationType::Type ClassifyNavigation(
+      const ViewHostMsg_FrameNavigate_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(NavigationEntry* entry);
+
+  // Handlers for the different types of navigation types. They will actually
+  // handle the navigations corresponding to the different NavClasses above.
+  // They will NOT broadcast the commit notification, that should be handled by
+  // the caller.
+  //
+  // RendererDidNavigateAutoSubframe is special, it may not actually change
+  // anything if some random subframe is loaded. It will return true if anything
+  // changed, or false if not.
+  void RendererDidNavigateToNewPage(
+      const ViewHostMsg_FrameNavigate_Params& params);
+  void RendererDidNavigateToExistingPage(
+      const ViewHostMsg_FrameNavigate_Params& params);
+  void RendererDidNavigateToSamePage(
+      const ViewHostMsg_FrameNavigate_Params& params);
+  void RendererDidNavigateInPage(
+      const ViewHostMsg_FrameNavigate_Params& params);
+  void RendererDidNavigateNewSubframe(
+      const ViewHostMsg_FrameNavigate_Params& params);
+  bool RendererDidNavigateAutoSubframe(
+      const ViewHostMsg_FrameNavigate_Params& params);
+
+  // Actually issues the navigation held in pending_entry.
+  void NavigateToPendingEntry(bool reload);
+
+  // Allows the derived class to issue notifications that a load has been
+  // committed. This will fill in the active entry to the details structure.
+  void NotifyNavigationEntryCommitted(LoadCommittedDetails* details);
+
+  // Returns the TabContents for the |entry|'s type. If the TabContents
+  // doesn't yet exist, it is created. If a new TabContents is created, its
+  // parent is |parent|.  Becomes part of |entry|'s SiteInstance.
+  TabContents* GetTabContentsCreateIfNecessary(const NavigationEntry& entry);
+
+  // Register the provided tab contents. This tab contents will be owned
+  // and deleted by this navigation controller
+  void RegisterTabContents(TabContents* some_contents);
+
+  // Sets the max restored page ID this NavigationController has seen, if it
+  // was restored from a previous session.
+  void set_max_restored_page_id(int max_id) { max_restored_page_id_ = max_id; }
+
+  NavigationEntry* CreateNavigationEntry(const GURL& url, const GURL& referrer,
+                                         PageTransition::Type transition);
+
+  // Invokes ScheduleTabContentsCollection for all TabContents but the active
+  // one.
+  void ScheduleTabContentsCollectionForInactiveTabs();
+
+  // Schedule the TabContents currently allocated for |tc| for collection.
+  // The TabContents will be destroyed later from a different event.
+  void ScheduleTabContentsCollection(TabContentsType t);
+
+  // Cancel the collection of the TabContents allocated for |tc|. This method
+  // is used when we keep using a TabContents because a provisional load failed.
+  void CancelTabContentsCollection(TabContentsType t);
+
+  // 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);
+
+  // Inserts an entry after the current position, removing all entries after it.
+  // The new entry will become the active one.
+  void InsertEntry(NavigationEntry* entry);
+
+  // Discards the pending and transient entries without updating
+  // active_contents_.
+  void DiscardNonCommittedEntriesInternal();
+
+  // Discards the transient entry without updating active_contents_.
+  void DiscardTransientEntry();
+
+  // ---------------------------------------------------------------------------
+
+  // The user profile associated with this controller
+  Profile* profile_;
+
+  // List of NavigationEntry for this tab
+  typedef std::vector<linked_ptr<NavigationEntry> > NavigationEntries;
+  NavigationEntries entries_;
+
+  // An entry we haven't gotten a response for yet.  This will be discarded
+  // when we navigate again.  It's used only so we know what the currently
+  // displayed tab is.
+  //
+  // This may refer to an item in the entries_ list if the pending_entry_index_
+  // == -1, or it may be its own entry that should be deleted. Be careful with
+  // the memory management.
+  NavigationEntry* pending_entry_;
+
+  // currently visible entry
+  int last_committed_entry_index_;
+
+  // index of pending entry if it is in entries_, or -1 if pending_entry_ is a
+  // new entry (created by LoadURL).
+  int pending_entry_index_;
+
+  // The index for the entry that is shown until a navigation occurs.  This is
+  // 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 poiting to an entry
+  // after the transient entry will become invalid if you navigate forward.
+  int transient_entry_index_;
+
+  // Tab contents. One entry per type used. The tab controller owns
+  // every tab contents used.
+  typedef std::map<TabContentsType, TabContents*> TabContentsMap;
+  TabContentsMap tab_contents_map_;
+
+  // A map of TabContentsType -> TabContentsCollector containing all the
+  // pending collectors.
+  typedef base::hash_map<TabContentsType, TabContentsCollector*>
+  TabContentsCollectorMap;
+  TabContentsCollectorMap tab_contents_collector_map_;
+
+  // The tab contents that is currently active.
+  TabContents* active_contents_;
+
+  // The max restored page ID in this controller, if it was restored.  We must
+  // store this so that WebContents can tell any renderer in charge of one of
+  // the restored entries to update its max page ID.
+  int max_restored_page_id_;
+
+  // Manages the SSL security UI
+  SSLManager ssl_manager_;
+
+  // Whether we need to be reloaded when made active.
+  bool needs_reload_;
+
+  // If true, the pending entry is lazy and should be loaded as soon as this
+  // controller becomes active.
+  bool load_pending_entry_when_active_;
+
+  // Unique identifier of this controller for session restore. This id is only
+  // unique within the current session, and is not guaranteed to be unique
+  // across sessions.
+  const SessionID session_id_;
+
+  // Unique identifier of the window we're in. Used by session restore.
+  SessionID window_id_;
+
+  // Should Reload check for post data? The default is true, but is set to false
+  // when testing.
+  static bool check_for_repost_;
+
+  // The maximum number of entries that a navigation controller can store.
+  static size_t max_entry_count_;
+
+  DISALLOW_COPY_AND_ASSIGN(NavigationController);
+};
+
+#endif  // CHROME_BROWSER_NAVIGATION_CONTROLLER_H_