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

content/browser/tab_contents/render_view_host_manager.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_RENDER_VIEW_HOST_MANAGER_H_
 #define CONTENT_BROWSER_TAB_CONTENTS_RENDER_VIEW_HOST_MANAGER_H_
 #pragma once
 
 #include "base/basictypes.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "content/browser/renderer_host/render_view_host_delegate.h"
 #include "content/browser/site_instance.h"
 #include "content/common/content_export.h"
 #include "content/public/browser/notification_observer.h"
 #include "content/public/browser/notification_registrar.h"
 
 class InterstitialPage;
 class NavigationController;
-class NavigationEntry;
 class RenderViewHost;
 class RenderWidgetHostView;
 class WebUI;
 
 namespace content {
 class BrowserContext;
 class NavigationEntry;
+class NavigationEntryImpl;
 }
 
 // Manages RenderViewHosts for a TabContents. Normally there is only one and
 // it is easy to do. But we can also have transitions of processes (and hence
 // RenderViewHosts) that can get complex.
 class CONTENT_EXPORT RenderViewHostManager
     : public RenderViewHostDelegate::RendererManagement,
       public content::NotificationObserver {
  public:
   // Functions implemented by our owner that we need.
@@ skipping 87 matching lines @@
   // Returns the current committed Web UI or NULL if none applies.
   WebUI* web_ui() const { return web_ui_.get(); }
 
   // Returns the Web UI for the pending navigation, or NULL of none applies.
   WebUI* pending_web_ui() const { return pending_web_ui_.get(); }
 
   // Called when we want to instruct the renderer to navigate to the given
   // navigation entry. It may create a new RenderViewHost or re-use an existing
   // one. The RenderViewHost to navigate will be returned. Returns NULL if one
   // could not be created.
-  RenderViewHost* Navigate(const NavigationEntry& entry);
+  RenderViewHost* Navigate(const content::NavigationEntryImpl& entry);
 
   // Instructs the various live views to stop. Called when the user directed the
   // page to stop loading.
   void Stop();
 
   // Notifies the regular and pending RenderViewHosts that a load is or is not
   // happening. Even though the message is only for one of them, we don't know
   // which one so we tell both.
   void SetIsLoading(bool is_loading);
 
@@ skipping 62 matching lines @@
   bool ShouldTransitionCrossSite();
 
   // Returns true if the two navigation entries are incompatible in some way
   // other than site instances. Cases where this can happen include Web UI
   // to regular web pages. It will cause us to swap RenderViewHosts (and hence
   // RenderProcessHosts) even if the site instance would otherwise be the same.
   // As part of this, we'll also force new SiteInstances and BrowsingInstances.
   // Either of the entries may be NULL.
   bool ShouldSwapProcessesForNavigation(
       const content::NavigationEntry* cur_entry,
-      const NavigationEntry* new_entry) const;
+      const content::NavigationEntryImpl* new_entry) const;
 
   // Returns an appropriate SiteInstance object for the given NavigationEntry,
   // possibly reusing the current SiteInstance.
   // Never called if --process-per-tab is used.
-  SiteInstance* GetSiteInstanceForEntry(const NavigationEntry& entry,
-                                        SiteInstance* curr_instance);
+  SiteInstance* GetSiteInstanceForEntry(
+      const content::NavigationEntryImpl& entry,
+      SiteInstance* curr_instance);
 
   // Helper method to create a pending RenderViewHost for a cross-site
   // navigation.
-  bool CreatePendingRenderView(const NavigationEntry& entry,
+  bool CreatePendingRenderView(const content::NavigationEntryImpl& entry,
                                SiteInstance* instance);
 
   // Sets up the necessary state for a new RenderViewHost navigating to the
   // given entry.
   bool InitRenderView(RenderViewHost* render_view_host,
-                      const NavigationEntry& entry);
+                      const content::NavigationEntryImpl& entry);
 
   // Sets the pending RenderViewHost/WebUI to be the active one. Note that this
   // doesn't require the pending render_view_host_ pointer to be non-NULL, since
   // there could be Web UI switching as well. Call this for every commit.
   void CommitPending();
 
   // Helper method to terminate the pending RenderViewHost.
   void CancelPending();
 
-  RenderViewHost* UpdateRendererStateForNavigate(const NavigationEntry& entry);
+  RenderViewHost* UpdateRendererStateForNavigate(
+      const content::NavigationEntryImpl& entry);
 
   // Called when a renderer process is starting to close.  We should not
   // schedule new navigations in its swapped out RenderViewHosts after this.
   void RendererProcessClosing(content::RenderProcessHost* render_process_host);
 
   // Our delegate, not owned by us. Guaranteed non-NULL.
   Delegate* delegate_;
 
   // Whether a navigation requiring different RenderView's is pending. This is
   // either cross-site request is (in the new process model), or when required
@@ skipping 36 matching lines @@
 };
 
 // The "details" for a NOTIFY_RENDER_VIEW_HOST_CHANGED notification. The old
 // host can be NULL when the first RenderViewHost is set.
 struct RenderViewHostSwitchedDetails {
   RenderViewHost* old_host;
   RenderViewHost* new_host;
 };
 
 #endif  // CONTENT_BROWSER_TAB_CONTENTS_RENDER_VIEW_HOST_MANAGER_H_