Replicating WebFrame::uniqueName across renderers.

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 <stddef.h>
 #include <stdint.h>
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/command_line.h"
 #include "base/location.h"
 #include "base/macros.h"
 #include "base/single_thread_task_runner.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/thread_task_runner_handle.h"
 #include "base/time/time.h"
 #include "base/win/windows_version.h"
 #include "build/build_config.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/frame_replication_state.h"
 #include "content/common/site_isolation_policy.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/browser_side_navigation_policy.h"
 #include "content/public/common/content_switches.h"
 #include "content/public/common/page_zoom.h"
@@ skipping 114 matching lines @@
   }
 };
 
 // Timestamps logged close to each other under low resolution timers
 // are more likely to record the same value. Allow for this by relaxing
 // constraints on systems with these timers.
 bool TimeTicksGT(const base::TimeTicks& x, const base::TimeTicks& y) {
   return base::TimeTicks::IsHighResolution() ? x > y : x >= y;
 }
 
+// FrameReplicationState is normally maintained in the browser process,
+// but the function below provides a way for tests to construct a partial
+// FrameReplicationState within the renderer process.  We say "partial",
+// because some fields of FrameReplicationState cannot be filled out
+// by content-layer, renderer code (still the constructed, partial
+// FrameReplicationState is sufficiently complete to avoid trigerring
+// asserts that a default/empty FrameReplicationState would).
+FrameReplicationState ReconstructReplicationStateForTesting(
+    TestRenderFrame* test_render_frame) {
+  blink::WebLocalFrame* frame = test_render_frame->GetWebFrame();
+
+  FrameReplicationState result;
+  // can't recover result.scope - no way to get WebTreeScopeType via public
+  // blink API...
+  result.name = base::UTF16ToUTF8(base::StringPiece16(frame->assignedName()));
+  result.unique_name =
+      base::UTF16ToUTF8(base::StringPiece16(frame->uniqueName()));
+  result.sandbox_flags = frame->effectiveSandboxFlags();
+  // result.should_enforce_strict_mixed_content_checking is calculated in the
+  // browser...
+  result.origin = frame->securityOrigin();
+
+  return result;
+}
+
 }  // namespace
 
 class RenderViewImplTest : public RenderViewTest {
  public:
   RenderViewImplTest() {
     // Attach a pseudo keyboard device to this object.
     mock_keyboard_.reset(new MockKeyboard());
   }
 
   ~RenderViewImplTest() override {}
@@ skipping 548 matching lines @@
   if (SiteIsolationPolicy::IsSwappedOutStateForbidden()) {
     return;
   }
   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.
-  frame()->SwapOut(kProxyRoutingId, true, content::FrameReplicationState());
+  frame()->SwapOut(kProxyRoutingId, true,
+                   ReconstructReplicationStateForTesting(frame()));
 
   // 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();
-  frame()->SwapOut(kProxyRoutingId, false, content::FrameReplicationState());
+  frame()->SwapOut(kProxyRoutingId, false,
+                   ReconstructReplicationStateForTesting(frame()));
   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)
   CommonNavigationParams common_params;
   RequestNavigationParams request_params;
   common_params.url = GURL("data:text/html,<div>Page B</div>");
   common_params.navigation_type = FrameMsg_Navigate_Type::NORMAL;
@@ skipping 47 matching lines @@
   request_params_A.page_id = 1;
   request_params_A.nav_entry_id = 1;
   request_params_A.page_state = state_A;
   frame()->Navigate(common_params_A, StartNavigationParams(), request_params_A);
   EXPECT_EQ(1, view()->historyBackListCount());
   EXPECT_EQ(2, view()->historyBackListCount() +
       view()->historyForwardListCount() + 1);
   ProcessPendingMessages();
 
   // Respond to a swap out request.
-  frame()->SwapOut(kProxyRoutingId, true, content::FrameReplicationState());
+  frame()->SwapOut(kProxyRoutingId, true,
+                   ReconstructReplicationStateForTesting(frame()));
 
   // 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 35 matching lines @@
 
   LoadHTML(
       "Hello <iframe src='data:text/html,frame 1'></iframe>"
       "<iframe src='data:text/html,frame 2'></iframe>");
   WebFrame* web_frame = frame()->GetWebFrame();
   TestRenderFrame* child_frame = static_cast<TestRenderFrame*>(
       RenderFrame::FromWebFrame(web_frame->firstChild()));
 
   // Swap the child frame out and pass a replicated origin to be set for
   // WebRemoteFrame.
-  content::FrameReplicationState replication_state;
+  content::FrameReplicationState replication_state =
+      ReconstructReplicationStateForTesting(child_frame);
   replication_state.origin = url::Origin(GURL("http://foo.com"));
   child_frame->SwapOut(kProxyRoutingId, true, 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.Serialize()));
@@ skipping 17 matching lines @@
   // This test should only run with --site-per-process.
   if (!AreAllSitesIsolatedForTesting())
     return;
 
   LoadHTML("Hello <iframe src='data:text/html,frame 1'></iframe>");
   WebFrame* web_frame = frame()->GetWebFrame();
   TestRenderFrame* child_frame = static_cast<TestRenderFrame*>(
       RenderFrame::FromWebFrame(web_frame->firstChild()));
 
   // Swap the child frame out.
-  child_frame->SwapOut(kProxyRoutingId, true, content::FrameReplicationState());
+  FrameReplicationState replication_state =
+      ReconstructReplicationStateForTesting(child_frame);
+  child_frame->SwapOut(kProxyRoutingId, true, replication_state);
   EXPECT_TRUE(web_frame->firstChild()->isWebRemoteFrame());
 
   // Do the first step of a remote-to-local transition for the child proxy,
   // which is to create a provisional local frame.
   int routing_id = kProxyRoutingId + 1;
   FrameMsg_NewFrame_WidgetParams widget_params;
   widget_params.routing_id = MSG_ROUTING_NONE;
   widget_params.hidden = false;
   RenderFrameImpl::CreateFrame(routing_id, kProxyRoutingId, MSG_ROUTING_NONE,
                                frame()->GetRoutingID(), MSG_ROUTING_NONE,
-                               content::FrameReplicationState(), nullptr,
-                               widget_params, blink::WebFrameOwnerProperties());
+                               replication_state, nullptr, widget_params,
+                               blink::WebFrameOwnerProperties());
   TestRenderFrame* provisional_frame =
       static_cast<TestRenderFrame*>(RenderFrameImpl::FromRoutingID(routing_id));
   EXPECT_TRUE(provisional_frame);
 
   // Detach the child frame (currently remote) in the main frame.
   ExecuteJavaScriptForTests(
       "document.body.removeChild(document.querySelector('iframe'));");
   RenderFrameProxy* child_proxy =
       RenderFrameProxy::FromRoutingID(kProxyRoutingId);
   EXPECT_FALSE(child_proxy);
@@ skipping 26 matching lines @@
   // shutdown of frame() in RenderViewTest.TearDown.
   blink::WebURLRequest popup_request(GURL("http://foo.com"));
   blink::WebView* new_web_view = view()->createView(
       GetMainFrame(), popup_request, blink::WebWindowFeatures(), "foo",
       blink::WebNavigationPolicyNewForegroundTab, false);
   RenderViewImpl* new_view = RenderViewImpl::FromWebView(new_web_view);
 
   // Respond to a swap out request.
   TestRenderFrame* new_main_frame =
       static_cast<TestRenderFrame*>(new_view->GetMainRenderFrame());
-  new_main_frame->SwapOut(kProxyRoutingId, true,
-                          content::FrameReplicationState());
+  new_main_frame->SwapOut(
+      kProxyRoutingId, true,
+      ReconstructReplicationStateForTesting(new_main_frame));
 
   // Simulate getting painted after swapping out.
   new_view->DidFlushPaint();
 
   new_view->Close();
   new_view->Release();
 }
 
 // Verify that the renderer process doesn't crash when device scale factor
 // changes after a cross-process navigation has commited.
 // See https://crbug.com/571603.
 TEST_F(RenderViewImplTest, SetZoomLevelAfterCrossProcessNavigation) {
   // This test should only run with out-of-process iframes enabled.
   if (!SiteIsolationPolicy::AreCrossProcessFramesPossible())
     return;
 
   // The bug reproduces if zoom is used for devices scale factor.
   base::CommandLine::ForCurrentProcess()->AppendSwitch(
       switches::kEnableUseZoomForDSF);
 
   LoadHTML("Hello world!");
 
   // Swap the main frame out after which it should become a WebRemoteFrame.
   TestRenderFrame* main_frame =
       static_cast<TestRenderFrame*>(view()->GetMainRenderFrame());
-  main_frame->SwapOut(kProxyRoutingId, true, content::FrameReplicationState());
+  main_frame->SwapOut(kProxyRoutingId, true,
+                      ReconstructReplicationStateForTesting(main_frame));
   EXPECT_TRUE(view()->webview()->mainFrame()->isWebRemoteFrame());
 
   // This should not cause a crash.
   view()->OnDeviceScaleFactorChanged();
 }
 
 // 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) {
@@ skipping 1757 matching lines @@
       FROM_HERE,
       base::Bind(&DevToolsAgentTest::CloseWhilePaused, base::Unretained(this)));
   ExecuteJavaScriptForTests("debugger;");
 
   // CloseWhilePaused should resume execution and continue here.
   EXPECT_FALSE(IsPaused());
   Detach();
 }
 
 }  // namespace content