Avoid creating a RenderWidgetHostView for proxies.

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 <map>
 
@@ skipping 98 matching lines @@
   // Functions and parameters whose description are prefixed by PlzNavigate are
   // part of a navigation refactoring project, currently behind the
   // enable-browser-side-navigation flag. The idea is to move the logic behind
   // driving navigations from the renderer to the browser.
   class CONTENT_EXPORT Delegate {
    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.
+    // automatically called from LoadURL.
     virtual bool CreateRenderViewForRenderManager(
         RenderViewHost* render_view_host,
         int opener_frame_routing_id,
         int proxy_routing_id,
-        const FrameReplicationState& replicated_frame_state,
-        bool for_main_frame_navigation) = 0;
+        const FrameReplicationState& replicated_frame_state) = 0;
+    virtual bool CreateRenderWidgetHostViewForRenderManager(

[Charlie Reis, 2015/08/31 19:02:51]

I still think we really need comments here.  It's proving very difficult to
understand what this function does or what parameters it expects.

[lfg, 2015/09/02 00:32:16]

I removed the parameter and simplified the function.

+        RenderViewHost* render_view_host,
+        bool main_frame_is_proxy) = 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,
         bool* proceed_to_fire_unload) = 0;
     virtual void RenderProcessGoneFromRenderManager(
         RenderViewHost* render_view_host) = 0;
@@ skipping 460 matching lines @@
   // Determines the appropriate url to use as the current url for SiteInstance
   // selection.
   const GURL& GetCurrentURLForSiteInstance(
       SiteInstance* current_instance,
       NavigationEntry* current_entry);
 
   // Creates a new RenderFrameHostImpl for the |new_instance| and assign it to
   // |pending_render_frame_host_| while respecting the opener route if needed
   // and stores it in pending_render_frame_host_.
   void CreatePendingRenderFrameHost(SiteInstance* old_instance,
-                                    SiteInstance* new_instance,
-                                    bool is_main_frame);
+                                    SiteInstance* new_instance);
 
   // 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|.
   void CreateProxiesForNewRenderFrameHost(SiteInstance* old_instance,
                                           SiteInstance* new_instance,
                                           int* create_render_frame_flags);
@@ skipping 36 matching lines @@
                                         SiteInstance* old_instance,
                                         SiteInstance* new_instance,
                                         int bindings);
 
   // 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.
   bool InitRenderView(RenderViewHostImpl* render_view_host,
-                      int proxy_routing_id,
-                      bool for_main_frame_navigation);
+                      int proxy_routing_id);
 
   // 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 139 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_