Move a bunch more code into the content namespace.

content/browser/web_contents/render_view_host_manager.h

 // Copyright (c) 2012 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_WEB_CONTENTS_RENDER_VIEW_HOST_MANAGER_H_
 #define CONTENT_BROWSER_WEB_CONTENTS_RENDER_VIEW_HOST_MANAGER_H_
 
 #include "base/basictypes.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/weak_ptr.h"
 #include "content/browser/renderer_host/render_view_host_delegate.h"
 #include "content/browser/site_instance_impl.h"
 #include "content/common/content_export.h"
 #include "content/public/browser/notification_observer.h"
 #include "content/public/browser/notification_registrar.h"
 
-class InterstitialPageImpl;
-class NavigationControllerImpl;
 class WebUIImpl;
 
 namespace content {
 class BrowserContext;
+class InterstitialPageImpl;
+class NavigationControllerImpl;
 class NavigationEntry;
 class NavigationEntryImpl;
 class RenderViewHost;
 class RenderViewHostImpl;
+class RenderViewHostManagerTest;
 class RenderWidgetHostDelegate;
 class RenderWidgetHostView;
 class TestWebContents;
 }
 
 // Manages RenderViewHosts for a WebContentsImpl. 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 content::RenderViewHostDelegate::RendererManagement,
@@ skipping 20 matching lines @@
     // InitWithExistingID.
     virtual bool CreateRenderViewForRenderManager(
         content::RenderViewHost* render_view_host, int opener_route_id) = 0;
     virtual void BeforeUnloadFiredFromRenderManager(
         bool proceed, const base::TimeTicks& proceed_time,
         bool* proceed_to_fire_unload) = 0;
     virtual void RenderViewGoneFromRenderManager(
         content::RenderViewHost* render_view_host) = 0;
     virtual void UpdateRenderViewSizeForRenderManager() = 0;
     virtual void NotifySwappedFromRenderManager() = 0;
-    virtual NavigationControllerImpl& GetControllerForRenderManager() = 0;
+    virtual content::NavigationControllerImpl&
+        GetControllerForRenderManager() = 0;
 
     // Create swapped out RenderViews in the given SiteInstance for each tab in
     // the opener chain of this tab, if any.  This allows the current tab to
     // make cross-process script calls to its opener(s).  Returns the route ID
     // of the immediate opener, if one exists (otherwise MSG_ROUTING_NONE).
     virtual int CreateOpenerRenderViewsForRenderManager(
         content::SiteInstance* instance) = 0;
 
     // Creates a WebUI object for the given URL if one applies. Ownership of the
     // returned pointer will be passed to the caller. If no WebUI applies,
@@ skipping 100 matching lines @@
   void SetWebUIPostCommit(WebUIImpl* web_ui);
 
   // Called when a provisional load on the given renderer is aborted.
   void RendererAbortedProvisionalLoad(
       content::RenderViewHost* render_view_host);
 
   // Sets the passed passed interstitial as the currently showing interstitial.
   // |interstitial_page| should be non NULL (use the remove_interstitial_page
   // method to unset the interstitial) and no interstitial page should be set
   // when there is already a non NULL interstitial page set.
-  void set_interstitial_page(InterstitialPageImpl* interstitial_page) {
+  void set_interstitial_page(content::InterstitialPageImpl* interstitial_page) {
     DCHECK(!interstitial_page_ && interstitial_page);
     interstitial_page_ = interstitial_page;
   }
 
   // Unsets the currently showing interstitial.
   void remove_interstitial_page() {
     DCHECK(interstitial_page_);
     interstitial_page_ = NULL;
   }
 
   // Returns the currently showing interstitial, NULL if no interstitial is
   // showing.
-  InterstitialPageImpl* interstitial_page() const {
+  content::InterstitialPageImpl* interstitial_page() const {
     return interstitial_page_;
   }
 
   // RenderViewHostDelegate::RendererManagement implementation.
   virtual void ShouldClosePage(
       bool for_cross_site_transition,
       bool proceed,
       const base::TimeTicks& proceed_time) OVERRIDE;
   virtual void OnCrossSiteResponse(int new_render_process_host_id,
                                    int new_request_id) OVERRIDE;
 
   // content::NotificationObserver implementation.
   virtual void Observe(int type,
                        const content::NotificationSource& source,
                        const content::NotificationDetails& details) OVERRIDE;
 
   // Called when a RenderViewHost is about to be deleted.
   void RenderViewDeleted(content::RenderViewHost* rvh);
 
   // Returns whether the given RenderViewHost is on the list of swapped out
   // RenderViewHosts.
   bool IsSwappedOut(content::RenderViewHost* rvh);
 
   // Returns the swapped out RenderViewHost for the given SiteInstance, if any.
   content::RenderViewHostImpl* GetSwappedOutRenderViewHost(
       content::SiteInstance* instance);
 
  private:
+  friend class content::RenderViewHostManagerTest;
   friend class content::TestWebContents;
-  friend class RenderViewHostManagerTest;
 
   // Returns whether this tab should transition to a new renderer for
   // cross-site URLs.  Enabled unless we see the --process-per-tab command line
   // switch.  Can be overridden in unit tests.
   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.
@@ skipping 70 matching lines @@
   // other should be NULL.
   scoped_ptr<WebUIImpl> pending_web_ui_;
   base::WeakPtr<WebUIImpl> pending_and_current_web_ui_;
 
   // A map of site instance ID to swapped out RenderViewHosts.
   typedef base::hash_map<int32, content::RenderViewHostImpl*> RenderViewHostMap;
   RenderViewHostMap swapped_out_hosts_;
 
   // The intersitial page currently shown if any, not own by this class
   // (the InterstitialPage is self-owned, it deletes itself when hidden).
-  InterstitialPageImpl* interstitial_page_;
+  content::InterstitialPageImpl* interstitial_page_;
 
   content::NotificationRegistrar registrar_;
 
   DISALLOW_COPY_AND_ASSIGN(RenderViewHostManager);
 };
 
 #endif  // CONTENT_BROWSER_WEB_CONTENTS_RENDER_VIEW_HOST_MANAGER_H_