Revert 263352 "Introduce RenderFrameProxyHost object and use it ..."

trunk/src/content/browser/frame_host/render_frame_host_manager.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_RENDER_FRAME_HOST_MANAGER_H_
 #define CONTENT_BROWSER_FRAME_HOST_RENDER_FRAME_HOST_MANAGER_H_
 
 #include "base/basictypes.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
@@ skipping 12 matching lines @@
 class CrossProcessFrameConnector;
 class CrossSiteTransferringRequest;
 class InterstitialPageImpl;
 class FrameTreeNode;
 class NavigationControllerImpl;
 class NavigationEntry;
 class NavigationEntryImpl;
 class RenderFrameHostDelegate;
 class RenderFrameHostImpl;
 class RenderFrameHostManagerTest;
-class RenderFrameProxyHost;
 class RenderViewHost;
 class RenderViewHostImpl;
 class RenderWidgetHostDelegate;
 class RenderWidgetHostView;
 class TestWebContents;
 class WebUIImpl;
 
 // Manages RenderFrameHosts for a FrameTreeNode.  This class acts as a state
 // machine to make cross-process navigations in a frame possible.
 class CONTENT_EXPORT RenderFrameHostManager : public NotificationObserver {
@@ skipping 218 matching lines @@
 
   // Called when a RenderViewHost is about to be deleted.
   void RenderViewDeleted(RenderViewHost* rvh);
 
   // Returns whether the given RenderFrameHost (or its associated
   // RenderViewHost) is on the list of swapped out RenderFrameHosts.
   bool IsRVHOnSwappedOutList(RenderViewHostImpl* rvh) const;
   bool IsOnSwappedOutList(RenderFrameHostImpl* rfh) const;
 
   // Returns the swapped out RenderViewHost or RenderFrameHost for the given
-  // SiteInstance, if any. This method is *deprecated* and
-  // GetRenderFrameProxyHost should be used.
+  // SiteInstance, if any.
   RenderViewHostImpl* GetSwappedOutRenderViewHost(SiteInstance* instance) const;
-  RenderFrameProxyHost* GetRenderFrameProxyHost(
+  RenderFrameHostImpl* GetSwappedOutRenderFrameHost(
       SiteInstance* instance) const;
 
   // Runs the unload handler in the current page, when we know that a pending
   // cross-process navigation is going to commit.  We may initiate a transfer
   // to a new process after this completes or times out.
   void SwapOutOldPage();
 
   // Deletes a RenderFrameHost that was pending shutdown.
   void ClearPendingShutdownRFHForSiteInstance(int32 site_instance_id,
                                               RenderFrameHostImpl* rfh);
@@ skipping 40 matching lines @@
     // This is the transition type for the original navigation.
     PageTransition page_transition;
 
     // This is the frame routing ID to use in RequestTransferURL.
     int render_frame_id;
 
     // This is whether the navigation should replace the current history entry.
     bool should_replace_current_entry;
   };
 
-  // Used with FrameTree::ForEach to erase RenderFrameProxyHosts from a
+  // Used with FrameTree::ForEach to erase inactive RenderFrameHosts from a
   // FrameTreeNode's RenderFrameHostManager.
-  static bool ClearProxiesInSiteInstance(int32 site_instance_id,
-                                         FrameTreeNode* node);
+  static bool ClearSwappedOutRFHsInSiteInstance(int32 site_instance_id,
+                                                FrameTreeNode* node);
 
   // 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 for the navigation from |current_entry| to |new_entry|,
   // a new SiteInstance and BrowsingInstance should be created (even if we are
   // in a process model that doesn't usually swap).  This forces a process swap
   // and severs script connections with existing tabs.  Cases where this can
@@ skipping 12 matching lines @@
   // Returns an appropriate SiteInstance object for the given NavigationEntry,
   // possibly reusing the current SiteInstance.  If --process-per-tab is used,
   // this is only called when ShouldSwapBrowsingInstancesForNavigation returns
   // true.
   SiteInstance* GetSiteInstanceForEntry(
       const NavigationEntryImpl& entry,
       SiteInstance* current_instance,
       bool force_browsing_instance_swap);
 
   // Creates a RenderFrameHost and corresponding RenderViewHost if necessary.
-  scoped_ptr<RenderFrameHostImpl> CreateRenderFrameHost(SiteInstance* instance,
-                                                        int view_routing_id,
-                                                        int frame_routing_id,
-                                                        bool swapped_out,
-                                                        bool hidden);
+  RenderFrameHostImpl* CreateRenderFrameHost(SiteInstance* instance,
+                                             int view_routing_id,
+                                             int frame_routing_id,
+                                             bool swapped_out,
+                                             bool hidden);
 
   // Sets up the necessary state for a new RenderViewHost with the given opener,
   // if necessary.  Returns early if the RenderViewHost has already been
   // initialized for another RenderFrameHost.
   // TODO(creis): opener_route_id is currently for the RenderViewHost but should
   // be for the RenderFrame, since frames can have openers.
   bool InitRenderView(RenderViewHost* render_view_host, int opener_route_id);
 
   // Sets the pending RenderFrameHost/WebUI to be the active one. Note that this
   // doesn't require the pending render_frame_host_ pointer to be non-NULL,
@@ skipping 55 matching lines @@
   // Tracks information about any current pending cross-process navigation.
   scoped_ptr<PendingNavigationParams> pending_nav_params_;
 
   // If either of these is non-NULL, the pending navigation is to a chrome:
   // page. The scoped_ptr is used if pending_web_ui_ != web_ui_, the WeakPtr is
   // used for when they reference the same object. If either is non-NULL, the
   // 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 RenderFrameProxyHosts.
-  typedef base::hash_map<int32, RenderFrameProxyHost*> RenderFrameProxyHostMap;
-  RenderFrameProxyHostMap proxy_hosts_;
+  // A map of site instance ID to swapped out RenderFrameHosts.  This may
+  // include pending_render_frame_host_ for navigations to existing entries.
+  typedef base::hash_map<int32, RenderFrameHostImpl*> RenderFrameHostMap;
+  RenderFrameHostMap swapped_out_hosts_;
 
   // A map of RenderFrameHosts pending shutdown.
   typedef base::hash_map<int32, linked_ptr<RenderFrameHostImpl> >
       RFHPendingDeleteMap;
   RFHPendingDeleteMap pending_delete_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_;
 
   NotificationRegistrar registrar_;
 
   // When |render_frame_host_| is in a different process from its parent in
   // the frame tree, this class connects its associated RenderWidgetHostView
   // to the proxy RenderFrameHost for the parent's renderer process. NULL
   // when |render_frame_host_| is the frame tree root or is in the same
   // process as its parent.
   CrossProcessFrameConnector* cross_process_frame_connector_;
 
   base::WeakPtrFactory<RenderFrameHostManager> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(RenderFrameHostManager);
 };
 
 }  // namespace content
 
 #endif  // CONTENT_BROWSER_FRAME_HOST_RENDER_FRAME_HOST_MANAGER_H_