Pass origin information for remote frame creation.

content/renderer/render_frame_proxy.h

 // 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.
 
 #ifndef CONTENT_RENDERER_RENDER_FRAME_PROXY_H_
 #define CONTENT_RENDERER_RENDER_FRAME_PROXY_H_
 
 #include "base/basictypes.h"
 #include "base/memory/ref_counted.h"
 #include "content/common/content_export.h"
 #include "ipc/ipc_listener.h"
 #include "ipc/ipc_sender.h"
 
 #include "third_party/WebKit/public/web/WebRemoteFrame.h"
 #include "third_party/WebKit/public/web/WebRemoteFrameClient.h"
 
 struct FrameMsg_BuffersSwapped_Params;
 struct FrameMsg_CompositorFrameSwapped_Params;
 
 namespace blink {
 class WebInputEvent;
 }
 
 namespace content {
 
 class ChildFrameCompositingHelper;
 class RenderFrameImpl;
 class RenderViewImpl;
+struct FrameReplicationState;
 
 // When a page's frames are rendered by multiple processes, each renderer has a
 // full copy of the frame tree. It has full RenderFrames for the frames it is
 // responsible for rendering and placeholder objects for frames rendered by
 // other processes. This class is the renderer-side object for the placeholder.
 // RenderFrameProxy allows us to keep existing window references valid over
 // cross-process navigations and route cross-site asynchronous JavaScript calls,
 // such as postMessage.
 //
 // For now, RenderFrameProxy is created when RenderFrame is swapped out. It
@@ skipping 28 matching lines @@
   // for example, after a cross-process navigation or after the addition of a
   // new frame local to some other process. |routing_id| will be the ID of the
   // newly created RenderFrameProxy. |parent_routing_id| is the routing ID of
   // the RenderFrameProxy to which the new frame is parented.
   // |render_view_routing_id| identifies the RenderView to be associated with
   // this frame.
   //
   // |parent_routing_id| always identifies a RenderFrameProxy (never a
   // RenderFrame) because a new child of a local frame should always start out
   // as a frame, not a proxy.
-  static RenderFrameProxy* CreateFrameProxy(int routing_id,
-                                            int parent_routing_id,
-                                            int render_view_routing_id);
+  static RenderFrameProxy* CreateFrameProxy(
+      int routing_id,
+      int parent_routing_id,
+      int render_view_routing_id,
+      const FrameReplicationState& replicated_state);
 
   // Returns the RenderFrameProxy for the given routing ID.
   static RenderFrameProxy* FromRoutingID(int routing_id);
 
   // Returns the RenderFrameProxy given a WebFrame.
   static RenderFrameProxy* FromWebFrame(blink::WebFrame* web_frame);
 
   ~RenderFrameProxy() override;
 
   // IPC::Sender
   bool Send(IPC::Message* msg) override;
 
   // Out-of-process child frames receive a signal from RenderWidgetCompositor
   // when a compositor frame has committed.
   void DidCommitCompositorFrame();
 
+  // Pass replicated information, such as security origin, to this
+  // RenderFrameProxy's WebRemoteFrame.
+  void SetReplicatedState(const FrameReplicationState& state);
+
   int routing_id() { return routing_id_; }
   RenderViewImpl* render_view() { return render_view_; }
   blink::WebRemoteFrame* web_frame() { return web_frame_; }
 
   // blink::WebRemoteFrameClient implementation:
   virtual void frameDetached();
   virtual void postMessageEvent(
       blink::WebLocalFrame* sourceFrame,
       blink::WebRemoteFrame* targetFrame,
       blink::WebSecurityOrigin target,
@@ skipping 31 matching lines @@
   scoped_refptr<ChildFrameCompositingHelper> compositing_helper_;
 
   RenderViewImpl* render_view_;
 
   DISALLOW_COPY_AND_ASSIGN(RenderFrameProxy);
 };
 
 }  // namespace
 
 #endif  // CONTENT_RENDERER_RENDER_FRAME_PROXY_H_