Make RenderFrame(Host) own a RenderWidget(Host).

content/browser/frame_host/render_frame_host_impl.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_IMPL_H_
 #define CONTENT_BROWSER_FRAME_HOST_RENDER_FRAME_HOST_IMPL_H_
 
 #include <map>
 #include <vector>
 
@@ skipping 41 matching lines @@
 
 class CrossProcessFrameConnector;
 class CrossSiteTransferringRequest;
 class FrameTree;
 class FrameTreeNode;
 class PermissionServiceContext;
 class RenderFrameHostDelegate;
 class RenderFrameProxyHost;
 class RenderProcessHost;
 class RenderViewHostImpl;
+class RenderWidgetHostDelegate;
 class RenderWidgetHostImpl;
+class RenderWidgetHostView;
 class StreamHandle;
 class TimeoutMonitor;
 struct CommitNavigationParams;
 struct CommonNavigationParams;
 struct ContextMenuParams;
 struct GlobalRequestID;
 struct Referrer;
 struct ResourceResponse;
 struct TransitionLayerData;
 
 // Flag arguments for RenderFrameHost creation.
 enum CreateRenderFrameFlags {
   // The RFH will be initially placed on the swapped out hosts list.
   CREATE_RF_SWAPPED_OUT = 1 << 0,
   // The new RenderFrame is being created for a navigation of the
   // top-level frame.
   CREATE_RF_FOR_MAIN_FRAME_NAVIGATION = 1 << 1,
   // The RenderFrame is initially hidden.
-  CREATE_RF_HIDDEN = 1 << 2
+  CREATE_RF_HIDDEN = 1 << 2,
+  // The RenderFrameHost will have a new RenderWidgetHost created and
+  // attached to it. This is used when the RenderFrameHost is the root
+  // of a subtree of frames that are being rendered in the same process.

[Charlie Reis, 2014/12/18 18:04:13]

Is this another way of saying it's used for subframes that are in a different
process from their parent?

The current wording seems to imply that we only use it when there are multiple
frames in the subtree, which I wouldn't think is true.

[kenrb, 2015/01/05 21:15:30]

I have changed it. The fact that a single node with no children is still the
root of a tree might be too subtle, although I was trying to find wording that
would include the main frame as well (which will eventually be created with a
RenderWidgetHost).

+  CREATE_RF_NEEDS_RENDER_WIDGET_HOST = 1 << 3
 };
 
 class CONTENT_EXPORT RenderFrameHostImpl
     : public RenderFrameHost,
       public BrowserAccessibilityDelegate {
  public:
   // Keeps track of the state of the RenderFrameHostImpl, particularly with
   // respect to swap out.
   enum RenderFrameHostImplState {
     // The standard state for a RFH handling the communication with an active
@@ skipping 90 matching lines @@
   // after they are blocked in RenderWidgetHelper::CreateNewWindow.
   void Init();
 
   int routing_id() const { return routing_id_; }
   void OnCreateChildFrame(int new_routing_id,
                           const std::string& frame_name);
 
   RenderViewHostImpl* render_view_host() { return render_view_host_; }
   RenderFrameHostDelegate* delegate() { return delegate_; }
   FrameTreeNode* frame_tree_node() { return frame_tree_node_; }
-  // TODO(nasko): The RenderWidgetHost will be owned by RenderFrameHost in
-  // the future, so update this accessor to return the right pointer.
+
+  // This is called to create RenderWidgetHosts for out-of-process iframes.
+  void CreateRenderWidgetHost(RenderWidgetHostDelegate* delegate, bool hidden);

[Charlie Reis, 2014/12/18 18:04:13]

Can we move this closer to CreateRenderFrame, rather than amongst these
accessors?

[kenrb, 2015/01/05 21:15:30]

Done.

+
+  // This returns the RenderFrameHost's owned RenderWidgetHost if it has one,
+  // or else it returns a pointer to the RenderViewHost (which inherits

[Charlie Reis, 2014/12/18 18:04:13]

In a grandchild case like A-embed-B1-embed-B2, what should this return for B2? 
I would have expected its parent's widget (B1's), not the root's (its RVH).

[kenrb, 2015/01/05 21:15:30]

We discussed this a couple of months ago, there is some question about this. It
seems strange to me that we would have a pointer to an arbitrary frame in the
tree and want the RenderWidgetHost for that receives input events for that
frame, and when I look at the use of this method I see that it is only ever
called on the main frame anyway. Returning nullptr for an RFH that doesn't have
a RWH makes more intuitive sense to me because it disambiguates whether the RFH
actually has one or not, but AFAICT it doesn't really matter either way.

[Charlie Reis, 2015/01/06 00:04:57]

I'm ok with returning nullptr if the RFH doesn't have a RWH.  (If such a need
ever existed, the caller could walk up to the nearest RFH with a RWH.)

Can we update the comment and code to behave that way?  In other words, return
the RVH if it's the main frame (for now), return the RWH if it has one, and
otherwise return nullptr.  (The current behavior is odd in that B2 would return
A's RVH if anyone asked it.)

[kenrb, 2015/01/06 17:39:03]

Done.

+  // RenderWidgetHost).
   RenderWidgetHostImpl* GetRenderWidgetHost();
 
+  // This returns the RenderWidgetHostView that can be used to control
+  // focus and visibility for this frame.
+  RenderWidgetHostView* GetView();
+
   // This function is called when this is a swapped out RenderFrameHost that
   // lives in the same process as the parent frame. The
   // |cross_process_frame_connector| allows the non-swapped-out
   // RenderFrameHost for a frame to communicate with the parent process
   // so that it may composite drawing data.
   //
   // Ownership is not transfered.
   void set_cross_process_frame_connector(
       CrossProcessFrameConnector* cross_process_frame_connector) {
     cross_process_frame_connector_ = cross_process_frame_connector;
@@ skipping 180 matching lines @@
 
  protected:
   friend class RenderFrameHostFactory;
 
   // |flags| is a combination of CreateRenderFrameFlags.
   // TODO(nasko): Remove dependency on RenderViewHost here. RenderProcessHost
   // should be the abstraction needed here, but we need RenderViewHost to pass
   // into WebContentsObserver::FrameDetached for now.
   RenderFrameHostImpl(RenderViewHostImpl* render_view_host,
                       RenderFrameHostDelegate* delegate,
+                      RenderWidgetHostDelegate* rwh_delegate,
                       FrameTree* frame_tree,
                       FrameTreeNode* frame_tree_node,
                       int routing_id,
                       int flags);
 
  private:
   friend class TestRenderFrameHost;
   friend class TestRenderViewHost;
 
   FRIEND_TEST_ALL_PREFIXES(SitePerProcessBrowserTest, CrashSubframe);
@@ skipping 119 matching lines @@
   // messages from the renderer requesting DOM manipulation.
   FrameTree* frame_tree_;
 
   // The FrameTreeNode which this RenderFrameHostImpl is hosted in.
   FrameTreeNode* frame_tree_node_;
 
   // The mapping of pending JavaScript calls created by
   // ExecuteJavaScript and their corresponding callbacks.
   std::map<int, JavaScriptResultCallback> javascript_callbacks_;
 
+  // Map from notification_id to a callback to cancel them.

[Charlie Reis, 2014/12/18 18:04:13]

This is a bit generic.  Can you say what these notifications and callbacks are
for, similar to how the previous member mentions ExecuteJavaScript?

[kenrb, 2015/01/05 21:15:30]

This isn't my code, I assume a merge resolution error during a rebase. Fixed
now.

+  std::map<int, base::Closure> cancel_notification_callbacks_;
+
+  // RenderFrameHosts that need management of the rendering and input events
+  // for their frame subtrees require RenderWidgetHosts. This typically
+  // means frames that are rendered in different processes from their parent
+  // frames.
+  // TODO(kenrb): Later this will also be used on the top-level frame.

[Charlie Reis, 2014/12/18 18:04:13]

... when RenderFrameHost owns its RenderViewHost.

(right?)

[kenrb, 2015/01/05 21:15:30]

I was thinking when RenderViewHost and RenderWidgetHost are decoupled, but
technically we could set this pointer when we do the ownership inversion, so I
guess you are right.

+  scoped_ptr<RenderWidgetHostImpl> render_widget_host_;
+
   int routing_id_;
 
   // The current state of this RenderFrameHost.
   RenderFrameHostImplState rfh_state_;
 
   // Tracks whether the RenderFrame for this RenderFrameHost has been created in
   // the renderer process.  Currently only used for subframes.
   // TODO(creis): Use this for main frames as well when RVH goes away.
   bool render_frame_created_;
 
@@ skipping 68 matching lines @@
 
   // NOTE: This must be the last member.
   base::WeakPtrFactory<RenderFrameHostImpl> weak_ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(RenderFrameHostImpl);
 };
 
 }  // namespace content
 
 #endif  // CONTENT_BROWSER_FRAME_HOST_RENDER_FRAME_HOST_IMPL_H_