Move browser-to-renderer opener plumbing to frame routing IDs

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 <list>
 
 #include "base/basictypes.h"
@@ skipping 103 matching lines @@
    public:
     // Initializes the given renderer if necessary and creates the view ID
     // corresponding to this view host. If this method is not called and the
     // process is not shared, then the WebContentsImpl will act as though the
     // renderer is not running (i.e., it will render "sad tab"). This method is
     // automatically called from LoadURL. |for_main_frame_navigation| indicates
     // whether this RenderViewHost is used to render a top-level frame, so the
     // appropriate RenderWidgetHostView type is used.
     virtual bool CreateRenderViewForRenderManager(
         RenderViewHost* render_view_host,
-        int opener_route_id,
+        int opener_frame_routing_id,
         int proxy_routing_id,
         const FrameReplicationState& replicated_frame_state,
         bool for_main_frame_navigation) = 0;
     virtual bool CreateRenderFrameForRenderManager(
         RenderFrameHost* render_frame_host,
         int parent_routing_id,
         int previous_sibling_routing_id,
         int proxy_routing_id) = 0;
     virtual void BeforeUnloadFiredFromRenderManager(
         bool proceed, const base::TimeTicks& proceed_time,
@@ skipping 211 matching lines @@
 
   // Creates and initializes a RenderFrameHost. The |web_ui| is an optional
   // input parameter used to double check bindings when swapping back in a
   // previously existing RenderFrameHost. If |flags| has the
   // CREATE_RF_SWAPPED_OUT bit set from the CreateRenderFrameFlags enum, it will
   // initially be placed on the swapped out hosts list. If |view_routing_id_ptr|
   // is not nullptr it will be set to the routing id of the view associated with
   // the frame.
   scoped_ptr<RenderFrameHostImpl> CreateRenderFrame(SiteInstance* instance,
                                                     WebUIImpl* web_ui,
-                                                    int opener_route_id,
                                                     int flags,
                                                     int* view_routing_id_ptr);
 
   // Helper method to create and initialize a RenderFrameProxyHost and return
-  // its routing id.
-  int CreateRenderFrameProxy(SiteInstance* instance);
+  // its routing id.  If |suppress_opener| is true, an opener frame won't be
+  // assigned for the corresponding RenderFrameProxy even if the current
+  // FrameTreeNode has an opener.
+  int CreateRenderFrameProxy(SiteInstance* instance, bool suppress_opener);
 
   // Creates proxies for a new child frame at FrameTreeNode |child| in all
   // SiteInstances for which the current frame has proxies.  This method is
   // called on the parent of a new child frame before the child leaves the
   // SiteInstance.
   void CreateProxiesForChildFrame(FrameTreeNode* child);
 
   // 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
@@ skipping 34 matching lines @@
   bool IsPendingDeletion(RenderFrameHostImpl* render_frame_host);
 
   // If |render_frame_host| is on the pending deletion list, this deletes it.
   // Returns whether it was deleted.
   bool DeleteFromPendingList(RenderFrameHostImpl* render_frame_host);
 
   // Deletes any proxy hosts associated with this node. Used during destruction
   // of WebContentsImpl.
   void ResetProxyHosts();
 
-  // Returns the routing id for a RenderFrameHost or RenderFrameHostProxy
+  // Returns the routing id for a RenderFrameHost or RenderFrameProxyHost

[nasko, 2015/07/07 16:26:21]

Nice catch!

   // that has the given SiteInstance and is associated with this
   // RenderFrameHostManager. Returns MSG_ROUTING_NONE if none is found.
   int GetRoutingIdForSiteInstance(SiteInstance* site_instance);
 
   // PlzNavigate
   // Notifies the RenderFrameHostManager that a new NavigationRequest has been
   // created and set in the FrameTreeNode so that it can speculatively create a
   // new RenderFrameHost (and potentially a new process) if needed.
   void DidCreateNavigationRequest(const NavigationRequest& request);
 
@@ skipping 27 matching lines @@
   // origin.
   void OnDidUpdateOrigin(const url::Origin& origin);
 
   void EnsureRenderViewInitialized(RenderViewHostImpl* render_view_host,
                                    SiteInstance* instance);
 
   // Recursively creates swapped out RenderViews and RenderFrameProxies for
   // this frame's FrameTree and for its opener chain in the given SiteInstance.
   // This allows other tabs to send cross-process JavaScript calls to their
   // opener(s) and to any other frames in the opener's FrameTree (e.g.,
-  // supporting calls like window.opener.opener.frames[x][y]). Returns the
-  // route ID of this frame's RenderView for |instance|.
-  // TODO(alexmos): Switch this to return RenderFrame routing IDs.
-  int CreateOpenerProxies(SiteInstance* instance);
+  // supporting calls like window.opener.opener.frames[x][y]).
+  void CreateOpenerProxies(SiteInstance* instance);
+
+  // Returns a routing ID for the current FrameTreeNode's opener node in the
+  // given SiteInstance.  May return a routing ID of either a RenderFrame (if

[nasko, 2015/07/07 16:26:21]

s/RenderFrame/RenderFrameHost/

[alexmos, 2015/07/08 04:42:18]

Done.

+  // opener's current or pending RFH has SiteInstance |instance|) or a
+  // RenderFrameProxy.  Returns MSG_ROUTING_NONE if there is no opener, or if

[nasko, 2015/07/07 16:26:21]

s/RenderFrameProxy/RenderFrameProxyHost/

[alexmos, 2015/07/08 04:42:18]

Done.

+  // the opener node doesn't have a proxy for |instance|.
+  int GetOpenerRoutingID(SiteInstance* instance);
 
   // Called on the RFHM of the inner WebContents to create a
   // RenderFrameProxyHost in its outer WebContents's SiteInstance,
   // |outer_contents_site_instance|. The frame in outer WebContents that is
   // hosting the inner WebContents is |render_frame_host|, and the frame will
   // be swapped out with the proxy.
   void CreateOuterDelegateProxy(SiteInstance* outer_contents_site_instance,
                                 RenderFrameHostImpl* render_frame_host);
 
   // Sets the child RenderWidgetHostView for this frame, which must be part of
@@ skipping 125 matching lines @@
   void CreatePendingRenderFrameHost(SiteInstance* old_instance,
                                     SiteInstance* new_instance,
                                     bool is_main_frame);
 
   // Ensure that we have created all needed proxies for a new RFH with
   // SiteInstance |new_instance|: (1) create swapped-out RVHs and proxies for
   // the new RFH's opener chain if we are staying in the same BrowsingInstance;
   // (2) Create proxies for the new RFH's SiteInstance in its own frame tree;
   // (3) set any additional flags for the new RenderFrame with
   // |create_render_frame_flags|.
-  // Returns the opener's RVH route ID to be used for the new RenderFrame.
-  // TODO(alexmos): switch this to return opener's RFH routing ID instead.
-  int CreateProxiesForNewRenderFrameHost(SiteInstance* old_instance,
-                                         SiteInstance* new_instance,
-                                         int* create_render_frame_flags);
+  void CreateProxiesForNewRenderFrameHost(SiteInstance* old_instance,
+                                          SiteInstance* new_instance,
+                                          int* create_render_frame_flags);
 
   // Create swapped out RenderViews and RenderFrameProxies in the given
   // SiteInstance for all frames on the opener chain of this frame.  Same as
-  // CreateOpenerProxies, but starts from this frame's opener, returning
-  // MSG_ROUTING_NONE if it doesn't exist, and calling CreateOpenerProxies if
-  // it does.
-  // TODO(alexmos): Switch this to return RenderFrame routing IDs.
-  int CreateOpenerProxiesIfNeeded(SiteInstance* instance);
+  // CreateOpenerProxies, but starts from this frame's opener, calling
+  // CreateOpenerProxies on it if it exists and returning otherwise.
+  void CreateOpenerProxiesIfNeeded(SiteInstance* instance);
 
   // Creates a RenderFrameHost and corresponding RenderViewHost if necessary.
   scoped_ptr<RenderFrameHostImpl> CreateRenderFrameHost(SiteInstance* instance,
                                                         int view_routing_id,
                                                         int frame_routing_id,
                                                         int flags);
 
   // PlzNavigate
   // Creates and initializes a speculative RenderFrameHost and/or WebUI for an
   // ongoing navigation. They might be destroyed and re-created later if the
   // navigation is redirected to a different SiteInstance.
   bool CreateSpeculativeRenderFrameHost(const GURL& url,
                                         SiteInstance* old_instance,
                                         SiteInstance* new_instance,
                                         int bindings);
 
-  // Sets up the necessary state for a new RenderViewHost with the given opener,
-  // if necessary.  It creates a RenderFrameProxy in the target renderer process
-  // with the given |proxy_routing_id|, which is used to route IPC messages when
-  // in swapped out state.  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.
+  // Sets up the necessary state for a new RenderViewHost.  Creates a
+  // RenderFrameProxy in the target renderer process with the given
+  // |proxy_routing_id|, which is used to route IPC messages when in swapped
+  // out state.  Returns early if the RenderViewHost has already been
+  // initialized for another RenderFrameHost.  If |suppress_opener| is true,
+  // an opener won't be assigned for the RenderView's main frame.
   bool InitRenderView(RenderViewHostImpl* render_view_host,
-                      int opener_route_id,
                       int proxy_routing_id,
-                      bool for_main_frame_navigation);
+                      bool for_main_frame_navigation,
+                      bool suppress_opener);
 
   // Initialization for RenderFrameHost uses the same sequence as InitRenderView
   // above.
   bool InitRenderFrame(RenderFrameHostImpl* render_frame_host);
 
   // 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,
   // since there could be Web UI switching as well. Call this for every commit.
   // If PlzNavigate is enabled the method will set the speculative (not pending)
   // RenderFrameHost to be the active one.
@@ skipping 138 matching lines @@
   bool should_reuse_web_ui_;
 
   base::WeakPtrFactory<RenderFrameHostManager> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(RenderFrameHostManager);
 };
 
 }  // namespace content
 
 #endif  // CONTENT_BROWSER_FRAME_HOST_RENDER_FRAME_HOST_MANAGER_H_