Replicate whether a frame is in a document or shadow tree.

content/renderer/render_frame_proxy.cc

 // Copyright 2014 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.
 
 #include "content/renderer/render_frame_proxy.h"
 
 #include <map>
 
 #include "base/lazy_instance.h"
 #include "content/child/webmessageportchannel_impl.h"
@@ skipping 21 matching lines @@
 
 // Facilitates lookup of RenderFrameProxy by WebFrame.
 typedef std::map<blink::WebFrame*, RenderFrameProxy*> FrameMap;
 base::LazyInstance<FrameMap> g_frame_map = LAZY_INSTANCE_INITIALIZER;
 
 }  // namespace
 
 // static
 RenderFrameProxy* RenderFrameProxy::CreateProxyToReplaceFrame(
     RenderFrameImpl* frame_to_replace,
-    int routing_id) {
+    int routing_id,
+    blink::WebTreeScopeType scope) {
   CHECK_NE(routing_id, MSG_ROUTING_NONE);
 
   scoped_ptr<RenderFrameProxy> proxy(
       new RenderFrameProxy(routing_id, frame_to_replace->GetRoutingID()));
 
   // When a RenderFrame is replaced by a RenderProxy, the WebRemoteFrame should
   // always come from WebRemoteFrame::create and a call to WebFrame::swap must
   // follow later.
-  blink::WebRemoteFrame* web_frame = blink::WebRemoteFrame::create(proxy.get());
+  blink::WebRemoteFrame* web_frame =
+      blink::WebRemoteFrame::create(scope, proxy.get());
   proxy->Init(web_frame, frame_to_replace->render_view());
   return proxy.release();
 }
 
 RenderFrameProxy* RenderFrameProxy::CreateFrameProxy(
     int routing_id,
     int parent_routing_id,
     int render_view_routing_id,
     const FrameReplicationState& replicated_state) {
   scoped_ptr<RenderFrameProxy> proxy(
       new RenderFrameProxy(routing_id, MSG_ROUTING_NONE));
   RenderViewImpl* render_view = NULL;
   blink::WebRemoteFrame* web_frame = NULL;
   if (parent_routing_id == MSG_ROUTING_NONE) {
     // Create a top level frame.
     render_view = RenderViewImpl::FromRoutingID(render_view_routing_id);
-    web_frame = blink::WebRemoteFrame::create(proxy.get());
+    web_frame =
+        blink::WebRemoteFrame::create(replicated_state.scope, proxy.get());
     render_view->webview()->setMainFrame(web_frame);
   } else {
     // Create a frame under an existing parent. The parent is always expected
     // to be a RenderFrameProxy, because navigations initiated by local frames
     // should not wind up here.
     RenderFrameProxy* parent =
         RenderFrameProxy::FromRoutingID(parent_routing_id);
     web_frame = parent->web_frame()->createRemoteChild(
+        replicated_state.scope,
         blink::WebString::fromUTF8(replicated_state.name),
         RenderFrameImpl::ContentToWebSandboxFlags(
             replicated_state.sandbox_flags),
         proxy.get());
     render_view = parent->render_view();
   }
 
   proxy->Init(web_frame, render_view);
 
   // Initialize proxy's WebRemoteFrame with the security origin and other
   // replicated information.
+  // TODO(dcheng): Shouldn't we only need to call when creating a top-level
+  // frame proxy?

[nasko, 2015/05/19 16:02:47]

Why would it apply only for top-level? What if we have Proxy->Proxy->Frame
nesting? Why wouldn't the middle proxy not need to know its origin? I thought we
need all of them to implement ancestorOrigins, no?

[dcheng, 2015/05/19 16:09:55]

In the case with a parent, most of this replicated state is already passed in
createRemoteChild()'s arguments: the only thing we don't pass right now is the
origin. Therefore line 94 redundantly sets the name and sandbox flags. You could
argue that we should be passing that as an argument to createRemoteChild() as
well, in which case line 94 would be completely redundant.

As a result, we'd only need to retain this for the no parent case, and we can
just move this into the if (parent_routing_id == MSG_ROUTING_NONE) block above.

[nasko, 2015/05/19 16:14:16]

I think passing all of the replication state into create* methods makes sense
and internally WebRemoteFrame can do the right thing. It will do away with the
extra call we make and code will be more streamlined. Also removes possible
issues with proxy->Init using data from the WebRemoteFrame before its
replication state is set.
 
I think we break up the replicated state into its components in a lot of places
after reading your CL. I wouldn't mind if we combine them all the time into the
struct and just pass the struct around.

[dcheng, 2015/05/19 16:18:49]

Well, we can't (easily) do it for the main frame case: the core Frame is only
initialized by the call to setMainFrame().
It'd make the calls in unit tests look pretty ugly though. Either way, when we
add a parameter, we'll need to update a bunch of tests and updating the tests
took the longest for this patch.

   proxy->SetReplicatedState(replicated_state);
 
   return proxy.release();
 }
 
 // static
 RenderFrameProxy* RenderFrameProxy::FromRoutingID(int32 routing_id) {
   RoutingIDProxyMap* proxies = g_routing_id_proxy_map.Pointer();
   RoutingIDProxyMap::iterator it = proxies->find(routing_id);
   return it == proxies->end() ? NULL : it->second;
@@ skipping 282 matching lines @@
       blink::WebUserGestureIndicator::isProcessingUserGesture();
   blink::WebUserGestureIndicator::consumeUserGesture();
   Send(new FrameHostMsg_OpenURL(routing_id_, params));
 }
 
 void RenderFrameProxy::forwardInputEvent(const blink::WebInputEvent* event) {
   Send(new FrameHostMsg_ForwardInputEvent(routing_id_, event));
 }
 
 }  // namespace