Make <webview> use out-of-process iframe architecture.

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 153 matching lines @@
     // to see what it should do.
     virtual bool FocusLocationBarByDefault() = 0;
 
     // Focuses the location bar.
     virtual void SetFocusToLocationBar(bool select_all) = 0;
 
     // Returns true if views created for this delegate should be created in a
     // hidden state.
     virtual bool IsHidden() = 0;
 
+    // If the delegate is an inner WebContents, this method returns the
+    // FrameTreeNode ID of the frame in the outer WebContents which hosts
+    // the inner WebContents. Returns FrameTreeNode::kFrameTreeNodeInvalidID
+    // if the delegate does not have an outer WebContents.
+    virtual int GetOuterDelegateFrameTreeNodeID() = 0;
+
    protected:
     virtual ~Delegate() {}
   };
 
   // Used with FrameTree::ForEach to delete RenderFrameHosts pending shutdown
   // from a FrameTreeNode's RenderFrameHostManager. Used during destruction of
   // WebContentsImpl.
   static bool ClearRFHsPendingShutdown(FrameTreeNode* node);
 
   // Returns true if we are currently in a mode where the swapped out state
@@ skipping 37 matching lines @@
     return render_frame_host_.get();
   }
 
   // TODO(creis): Remove this when we no longer use RVH for navigation.
   RenderViewHostImpl* current_host() const;
 
   // Returns the view associated with the current RenderViewHost, or NULL if
   // there is no current one.
   RenderWidgetHostView* GetRenderWidgetHostView() const;
 
+  // Returns whether this manager belongs to a FrameTreeNode that is a main
+  // frame in an inner WebContents.
+  // TODO(lazyboy): Make this work correctly for subframes inside inner
+  // WebContents too.
+  bool ForInnerDelegate();
+
+  // Returns the RenderWidgetHost of the outer WebContents (if any) that can be
+  // used to fetch the last keyboard event.
+  // TODO(lazyboy): This can be removed once input events are sent directly to
+  // remote frames.
+  RenderWidgetHostImpl* GetOuterRenderWidgetHostForKeyboardInput();
+
   RenderFrameProxyHost* GetProxyToParent();
 
+  // Returns the proxy to inner WebContents in the outer WebContents's
+  // SiteInstance. Returns nullptr if this WebContents isn't part of inner/outer
+  // relationship.
+  RenderFrameProxyHost* GetProxyToOuterDelegate();
+
+  // Removes the FrameTreeNode in the outer WebContents that represents this
+  // FrameTreeNode.
+  // TODO(lazyboy): This does not belong to RenderFrameHostManager, move it to
+  // somehwere else.
+  void RemoveOuterDelegateFrame();
+
   // Returns the pending RenderFrameHost, or NULL if there is no pending one.
   RenderFrameHostImpl* pending_frame_host() const {
     return pending_render_frame_host_.get();
   }
 
   // Returns the speculative RenderFrameHost, or null if there is no speculative
   // one.
   RenderFrameHostImpl* speculative_frame_host_for_testing() const {
     return speculative_render_frame_host_.get();
   }
@@ skipping 188 matching lines @@
 
   // 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);
 
+  // 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
+  // an inner WebContents.
+  void SetRWHViewForInnerContents(RenderWidgetHostView* child_rwhv);
+
  private:
   friend class FrameTreeVisualizer;
   friend class NavigatorTestWithBrowserSideNavigation;
   friend class RenderFrameHostManagerTest;
   friend class TestWebContents;
 
   // Stores information regarding a SiteInstance targeted at a specific URL to
   // allow for comparisons without having to actually create new instances. It
   // can point to an existing one or store the details needed to create a new
   // one.
@@ skipping 310 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_