Pass origin information for remote frame creation.

content/renderer/render_view_browsertest.cc

 // Copyright (c) 2012 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 "base/basictypes.h"
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/memory/shared_memory.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/time/time.h"
 #include "base/win/windows_version.h"
 #include "content/child/request_extra_data.h"
 #include "content/child/service_worker/service_worker_network_provider.h"
 #include "content/common/frame_messages.h"
 #include "content/common/ssl_status_serialization.h"
 #include "content/common/view_messages.h"
 #include "content/public/browser/browser_context.h"
 #include "content/public/browser/native_web_keyboard_event.h"
 #include "content/public/browser/web_ui_controller_factory.h"
 #include "content/public/common/bindings_policy.h"
+#include "content/public/common/content_switches.h"
 #include "content/public/common/page_zoom.h"
 #include "content/public/common/url_constants.h"
 #include "content/public/common/url_utils.h"
 #include "content/public/renderer/content_renderer_client.h"
 #include "content/public/renderer/document_state.h"
 #include "content/public/renderer/navigation_state.h"
 #include "content/public/test/browser_test_utils.h"
 #include "content/public/test/frame_load_waiter.h"
 #include "content/public/test/render_view_test.h"
 #include "content/public/test/test_utils.h"
@@ skipping 492 matching lines @@
 // Ensure the RenderViewImpl sends an ACK to a SwapOut request, even if it is
 // already swapped out.  http://crbug.com/93427.
 TEST_F(RenderViewImplTest, SendSwapOutACK) {
   LoadHTML("<div>Page A</div>");
   int initial_page_id = view_page_id();
 
   // Increment the ref count so that we don't exit when swapping out.
   RenderProcess::current()->AddRefProcess();
 
   // Respond to a swap out request.
-  view()->GetMainRenderFrame()->OnSwapOut(kProxyRoutingId);
+  view()->GetMainRenderFrame()->OnSwapOut(kProxyRoutingId,
+                                          content::FrameReplicationState());
 
   // Ensure the swap out commits synchronously.
   EXPECT_NE(initial_page_id, view_page_id());
 
   // Check for a valid OnSwapOutACK.
   const IPC::Message* msg = render_thread_->sink().GetUniqueMessageMatching(
       FrameHostMsg_SwapOut_ACK::ID);
   ASSERT_TRUE(msg);
 
   // It is possible to get another swap out request.  Ensure that we send
   // an ACK, even if we don't have to do anything else.
   render_thread_->sink().ClearMessages();
-  view()->GetMainRenderFrame()->OnSwapOut(kProxyRoutingId);
+  view()->GetMainRenderFrame()->OnSwapOut(kProxyRoutingId,
+                                          content::FrameReplicationState());
   const IPC::Message* msg2 = render_thread_->sink().GetUniqueMessageMatching(
       FrameHostMsg_SwapOut_ACK::ID);
   ASSERT_TRUE(msg2);
 
   // If we navigate back to this RenderView, ensure we don't send a state
   // update for the swapped out URL.  (http://crbug.com/72235)
   FrameMsg_Navigate_Params nav_params;
   nav_params.common_params.url = GURL("data:text/html,<div>Page B</div>");
   nav_params.common_params.navigation_type = FrameMsg_Navigate_Type::NORMAL;
   nav_params.common_params.transition = ui::PAGE_TRANSITION_TYPED;
@@ skipping 39 matching lines @@
   params_A.current_history_list_offset = 1;
   params_A.pending_history_list_offset = 0;
   params_A.page_id = 1;
   params_A.commit_params.page_state = state_A;
   params_A.commit_params.browser_navigation_start =
       base::TimeTicks::FromInternalValue(1);
   frame()->OnNavigate(params_A);
   ProcessPendingMessages();
 
   // Respond to a swap out request.
-  view()->GetMainRenderFrame()->OnSwapOut(kProxyRoutingId);
+  view()->GetMainRenderFrame()->OnSwapOut(kProxyRoutingId,
+                                          content::FrameReplicationState());
 
   // Check for a OnSwapOutACK.
   const IPC::Message* msg = render_thread_->sink().GetUniqueMessageMatching(
       FrameHostMsg_SwapOut_ACK::ID);
   ASSERT_TRUE(msg);
   render_thread_->sink().ClearMessages();
 
   // It is possible to get a reload request at this point, containing the
   // params.page_state of the initial page (e.g., if the new page fails the
   // provisional load in the renderer process, after we unload the old page).
@@ skipping 18 matching lines @@
           FrameHostMsg_DidCommitProvisionalLoad::ID);
   EXPECT_TRUE(frame_navigate_msg);
 
   // Read URL out of the parent trait of the params object.
   FrameHostMsg_DidCommitProvisionalLoad::Param commit_params;
   FrameHostMsg_DidCommitProvisionalLoad::Read(frame_navigate_msg,
                                               &commit_params);
   EXPECT_NE(GURL("swappedout://"), commit_params.a.url);
 }
 
+// Verify that security origins are replicated properly to RenderFrameProxies
+// when swapping out.
+TEST_F(RenderViewImplTest, OriginReplicationForSwapOut) {
+  // This test should only run with --site-per-process, since origin
+  // replication only happens in that mode.
+  if (!CommandLine::ForCurrentProcess()->HasSwitch(switches::kSitePerProcess))
+    return;
+
+  LoadHTML(
+      "Hello <iframe src='data:text/html,frame 1'></iframe>"
+      "<iframe src='data:text/html,frame 2'></iframe>");
+  WebFrame* web_frame = frame()->GetWebFrame();
+  RenderFrameImpl* child_frame = static_cast<RenderFrameImpl*>(
+      RenderFrame::FromWebFrame(web_frame->firstChild()));
+
+  // Swap the child frame out and pass a serialized origin to be set for
+  // WebRemoteFrame.
+  content::FrameReplicationState replication_state;
+  replication_state.origin = url::Origin("http://foo.com");
+  child_frame->OnSwapOut(kProxyRoutingId, replication_state);
+
+  // The child frame should now be a WebRemoteFrame.
+  EXPECT_TRUE(web_frame->firstChild()->isWebRemoteFrame());
+
+  // Expect the origin to be updated properly.
+  blink::WebSecurityOrigin origin = web_frame->firstChild()->securityOrigin();
+  EXPECT_EQ(origin.toString(),
+            WebString::fromUTF8(replication_state.origin.string()));
+
+  // Now, swap out the second frame using a unique origin and verify that it is
+  // replicated correctly.
+  replication_state.origin = url::Origin();
+  RenderFrameImpl* child_frame2 = static_cast<RenderFrameImpl*>(
+      RenderFrame::FromWebFrame(web_frame->lastChild()));
+  child_frame2->OnSwapOut(kProxyRoutingId + 1, replication_state);
+  EXPECT_TRUE(web_frame->lastChild()->isWebRemoteFrame());
+  EXPECT_TRUE(web_frame->lastChild()->securityOrigin().isUnique());
+}
 
 // Test that we get the correct UpdateState message when we go back twice
 // quickly without committing.  Regression test for http://crbug.com/58082.
 // Disabled: http://crbug.com/157357 .
 TEST_F(RenderViewImplTest,  DISABLED_LastCommittedUpdateState) {
   // Load page A.
   LoadHTML("<div>Page A</div>");
 
   // Load page B, which will trigger an UpdateState message for page A.
   LoadHTML("<div>Page B</div>");
@@ skipping 1838 matching lines @@
 
   gfx::Size initial_size_;
 };
 
 TEST_F(RenderViewImplInitialSizeTest, InitialSize) {
   ASSERT_EQ(initial_size_, view_->GetSize());
   ASSERT_EQ(initial_size_, gfx::Size(view_->GetWebView()->size()));
 }
 
 }  // namespace content