Rename NavigationController to NavigationControllerImpl and put it into the content namespace. Al...

content/browser/tab_contents/navigation_controller.h

 // Copyright (c) 2011 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_TAB_CONTENTS_NAVIGATION_CONTROLLER_H_
 #define CONTENT_BROWSER_TAB_CONTENTS_NAVIGATION_CONTROLLER_H_
 #pragma once
 
 #include "build/build_config.h"
 
 #include <string>
 #include <vector>
 
 #include "base/memory/linked_ptr.h"
 #include "base/time.h"
 #include "googleurl/src/gurl.h"
 #include "content/browser/ssl/ssl_manager.h"
 #include "content/common/content_export.h"
 #include "content/public/browser/global_request_id.h"
 #include "content/public/browser/navigation_type.h"
 #include "content/public/common/page_transition_types.h"
 #include "content/public/common/referrer.h"
 
-class NavigationEntry;
 class SessionStorageNamespace;
 class SiteInstance;
 class TabContents;
 struct ViewHostMsg_FrameNavigate_Params;
 
 namespace content {
 class BrowserContext;
 class NavigationEntry;
+class NavigationEntryImpl;
 struct LoadCommittedDetails;
 struct Referrer;
 }
 
 // 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 CONTENT_EXPORT NavigationController {
@@ skipping 79 matching lines @@
   }
 
   content::NavigationEntry* GetEntryAtIndex(int index) const;
 
   // Returns the entry at the specified offset from current.  Returns NULL
   // if out of bounds.
   content::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;
+  int GetIndexOfEntry(const content::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 entry with the corresponding instance and page_id, or NULL if
   // not found.
-  NavigationEntry* GetEntryWithPageID(SiteInstance* instance,
-                                      int32 page_id) const;
+  content::NavigationEntryImpl* GetEntryWithPageID(SiteInstance* instance,
+                                                   int32 page_id) const;
 
   // Pending entry -------------------------------------------------------------
 
   // Discards the pending and transient entries if any.
   void DiscardNonCommittedEntries();
 
   // Returns the pending entry corresponding to the navigation that is
   // currently in progress, or null if there is none.
   content::NavigationEntry* GetPendingEntry() const;
 
   // Returns the index of the pending entry or -1 if the pending entry
   // corresponds to a new navigation (created via LoadURL).
   int pending_entry_index() 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);
+  void AddTransientEntry(content::NavigationEntryImpl* 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.
   content::NavigationEntry* GetTransientEntry() const;
 
   // New navigations -----------------------------------------------------------
 
   // Loads the specified URL, specifying extra http headers to add to the
   // request.  Extra headers are separated by \n.
   void LoadURL(const GURL& url,
@@ skipping 168 matching lines @@
   // Creates navigation entry and translates the virtual url to a real one.
   // Used when navigating to a new URL using LoadURL.  Extra headers are
   // separated by \n.
   static content::NavigationEntry* CreateNavigationEntry(
       const GURL& url,
       const content::Referrer& referrer,
       content::PageTransition transition,
       bool is_renderer_initiated,
       const std::string& extra_headers,
       content::BrowserContext* browser_context);
-  static NavigationEntry* CreateNavigationEntryImpl(
+  static content::NavigationEntryImpl* CreateNavigationEntryImpl(
       const GURL& url,
       const content::Referrer& referrer,
       content::PageTransition transition,
       bool is_renderer_initiated,
       const std::string& extra_headers,
       content::BrowserContext* browser_context);
 
  private:
   class RestoreHelper;
   friend class RestoreHelper;
   friend class TabContents;  // For invoking OnReservedPageIDRange.
 
   // Classifies the given renderer navigation (see the NavigationType enum).
   content::NavigationType 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);
+  void LoadEntry(content::NavigationEntryImpl* 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.
   //
@@ skipping 18 matching lines @@
 
   // Actually issues the navigation held in pending_entry.
   void NavigateToPendingEntry(ReloadType reload_type);
 
   // 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(content::LoadCommittedDetails* details);
 
   // Updates the virtual URL of an entry to match a new URL, for cases where
   // the real renderer URL is derived from the virtual URL, like view-source:
-  void UpdateVirtualURLToURL(NavigationEntry* entry, const GURL& new_url);
+  void UpdateVirtualURLToURL(content::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. See RestoreFromState for a description of from_last_session.
   void FinishRestore(int selected_index, bool from_last_session);
 
   // 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(NavigationEntry* entry, bool replace);
+  void InsertOrReplaceEntry(content::NavigationEntryImpl* entry, bool replace);
 
   // Removes the entry at |index|, as long as it is not the current entry.
   void RemoveEntryAtIndexInternal(int index);
 
   // Discards the pending and transient entries.
   void DiscardNonCommittedEntriesInternal();
 
   // Discards the transient entry.
   void DiscardTransientEntry();
 
   // Returns true if the navigation is redirect.
   bool IsRedirect(const ViewHostMsg_FrameNavigate_Params& params);
 
   // Returns true if the navigation is likley to be automatic rather than
   // user-initiated.
   bool IsLikelyAutoNavigation(base::TimeTicks now);
 
   // 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 NavigationController& source, int max_index);
 
   // ---------------------------------------------------------------------------
 
   // The user browser context associated with this controller.
   content::BrowserContext* browser_context_;
 
   // List of NavigationEntry for this tab
-  typedef std::vector<linked_ptr<NavigationEntry> > NavigationEntries;
+  typedef std::vector<linked_ptr<content::NavigationEntryImpl> >
+      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_;
+  content::NavigationEntryImpl* 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.
@@ skipping 31 matching lines @@
   static size_t max_entry_count_for_testing_;
 
   // If a repost is pending, its type (RELOAD or RELOAD_IGNORING_CACHE),
   // NO_RELOAD otherwise.
   ReloadType pending_reload_;
 
   DISALLOW_COPY_AND_ASSIGN(NavigationController);
 };
 
 #endif  // CONTENT_BROWSER_TAB_CONTENTS_NAVIGATION_CONTROLLER_H_