Replicate WebInsecureRequestPolicy instead of a bool for strict mixed content checks.

content/browser/frame_host/render_frame_host_manager_unittest.cc

 // 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.
 
 #include "content/browser/frame_host/render_frame_host_manager.h"
 
 #include <stdint.h>
 
 #include <tuple>
 #include <utility>
@@ skipping 37 matching lines @@
 #include "content/public/test/test_notification_tracker.h"
 #include "content/public/test/test_utils.h"
 #include "content/test/browser_side_navigation_test_utils.h"
 #include "content/test/test_content_browser_client.h"
 #include "content/test/test_content_client.h"
 #include "content/test/test_render_frame_host.h"
 #include "content/test/test_render_view_host.h"
 #include "content/test/test_web_contents.h"
 #include "net/base/load_flags.h"
 #include "testing/gtest/include/gtest/gtest.h"
+#include "third_party/WebKit/public/platform/WebInsecureRequestPolicy.h"
 #include "third_party/WebKit/public/web/WebFrameOwnerProperties.h"
 #include "third_party/WebKit/public/web/WebSandboxFlags.h"
 #include "ui/base/page_transition_types.h"
 
 namespace content {
 namespace {
 
 // Helper to check that the provided RenderProcessHost received exactly one
 // page focus message with the provided focus and routing ID values.
 void VerifyPageFocusMessage(MockRenderProcessHost* rph,
                             bool expected_focus,
                             int expected_routing_id) {
   const IPC::Message* message =
       rph->sink().GetUniqueMessageMatching(InputMsg_SetFocus::ID);
   EXPECT_TRUE(message);
   EXPECT_EQ(expected_routing_id, message->routing_id());
   InputMsg_SetFocus::Param params;
   EXPECT_TRUE(InputMsg_SetFocus::Read(message, &params));
   EXPECT_EQ(expected_focus, std::get<0>(params));
 }
 
 // Helper function for strict mixed content checking tests.
-void CheckMixedContentIPC(TestRenderFrameHost* rfh,
-                          bool expected_param,
-                          int expected_routing_id) {
+void CheckInsecureRequestPolicyIPC(
+    TestRenderFrameHost* rfh,
+    blink::WebInsecureRequestPolicy expected_param,
+    int expected_routing_id) {
   const IPC::Message* message =
       rfh->GetProcess()->sink().GetUniqueMessageMatching(
-          FrameMsg_EnforceStrictMixedContentChecking::ID);
+          FrameMsg_EnforceInsecureRequestPolicy::ID);
   ASSERT_TRUE(message);
   EXPECT_EQ(expected_routing_id, message->routing_id());
-  FrameMsg_EnforceStrictMixedContentChecking::Param params;
-  EXPECT_TRUE(
-      FrameMsg_EnforceStrictMixedContentChecking::Read(message, &params));
+  FrameMsg_EnforceInsecureRequestPolicy::Param params;
+  EXPECT_TRUE(FrameMsg_EnforceInsecureRequestPolicy::Read(message, &params));
   EXPECT_EQ(expected_param, std::get<0>(params));
 }
 
 class RenderFrameHostManagerTestWebUIControllerFactory
     : public WebUIControllerFactory {
  public:
   RenderFrameHostManagerTestWebUIControllerFactory()
       : should_create_webui_(false), type_(1) {
     CHECK_NE(reinterpret_cast<WebUI::TypeID>(type_), WebUI::kNoWebUI);
   }
@@ skipping 2908 matching lines @@
   // The RenderFrameHost committed.
   manager->DidNavigateFrame(speculative_host, true);
   EXPECT_EQ(speculative_host, manager->current_frame_host());
   EXPECT_EQ(next_web_ui, manager->current_frame_host()->web_ui());
   EXPECT_FALSE(GetPendingFrameHost(manager));
   EXPECT_FALSE(speculative_host->pending_web_ui());
   EXPECT_FALSE(manager->GetNavigatingWebUI());
 }
 
 // Tests that frame proxies receive updates when a frame's enforcement
-// of strict mixed content checking changes.
+// of insecure request policy changes.
 TEST_F(RenderFrameHostManagerTestWithSiteIsolation,
-       ProxiesReceiveShouldEnforceStrictMixedContentChecking) {
+       ProxiesReceiveInsecureRequestPolicy) {
   const GURL kUrl1("http://www.google.test");
   const GURL kUrl2("http://www.google2.test");
   const GURL kUrl3("http://www.google2.test/foo");
 
   contents()->NavigateAndCommit(kUrl1);
 
   // Create a child frame and navigate it cross-site.
   main_test_rfh()->OnCreateChildFrame(
       main_test_rfh()->GetProcess()->GetNextRoutingID(),
       blink::WebTreeScopeType::Document, "frame1", "uniqueName1",
@@ skipping 11 matching lines @@
   TestRenderFrameHost* child_host =
       static_cast<TestRenderFrameHost*>(NavigateToEntry(child, entry1));
   child->DidNavigateFrame(child_host, true);
 
   // Verify that parent and child are in different processes.
   EXPECT_NE(child_host->GetProcess(), main_test_rfh()->GetProcess());
 
   // Change the parent's enforcement of strict mixed content checking,
   // and check that the correct IPC is sent to the child frame's
   // process.
-  EXPECT_FALSE(root->current_replication_state()
-                   .should_enforce_strict_mixed_content_checking);
-  main_test_rfh()->DidEnforceStrictMixedContentChecking();
+  EXPECT_EQ(blink::kLeaveInsecureRequestsAlone,
+            root->current_replication_state().insecure_request_policy);
+  main_test_rfh()->DidEnforceInsecureRequestPolicy(
+      blink::kBlockAllMixedContent);
   RenderFrameProxyHost* proxy_to_child =
       root->render_manager()->GetRenderFrameProxyHost(
           child_host->GetSiteInstance());
   EXPECT_NO_FATAL_FAILURE(
-      CheckMixedContentIPC(child_host, true, proxy_to_child->GetRoutingID()));
-  EXPECT_TRUE(root->current_replication_state()
-                  .should_enforce_strict_mixed_content_checking);
+      CheckInsecureRequestPolicyIPC(child_host, blink::kBlockAllMixedContent,
+                                    proxy_to_child->GetRoutingID()));
+  EXPECT_EQ(blink::kBlockAllMixedContent,
+            root->current_replication_state().insecure_request_policy);
 
   // Do the same for the child's enforcement. In general, the parent
   // needs to know the status of the child's flag in case a grandchild
   // is created: if A.com embeds B.com, and B.com enforces strict mixed
   // content checking, and B.com adds an iframe to A.com, then the
   // A.com process needs to know B.com's flag so that the grandchild
   // A.com frame can inherit it.
-  EXPECT_FALSE(root->child_at(0)
-                   ->current_replication_state()
-                   .should_enforce_strict_mixed_content_checking);
-  child_host->DidEnforceStrictMixedContentChecking();
+  EXPECT_EQ(
+      blink::kLeaveInsecureRequestsAlone,
+      root->child_at(0)->current_replication_state().insecure_request_policy);
+  child_host->DidEnforceInsecureRequestPolicy(blink::kBlockAllMixedContent);
   RenderFrameProxyHost* proxy_to_parent =
       child->GetRenderFrameProxyHost(main_test_rfh()->GetSiteInstance());
-  EXPECT_NO_FATAL_FAILURE(CheckMixedContentIPC(
-      main_test_rfh(), true, proxy_to_parent->GetRoutingID()));
-  EXPECT_TRUE(root->child_at(0)
-                  ->current_replication_state()
-                  .should_enforce_strict_mixed_content_checking);
+  EXPECT_NO_FATAL_FAILURE(CheckInsecureRequestPolicyIPC(
+      main_test_rfh(), blink::kBlockAllMixedContent,
+      proxy_to_parent->GetRoutingID()));
+  EXPECT_EQ(
+      blink::kBlockAllMixedContent,
+      root->child_at(0)->current_replication_state().insecure_request_policy);
 
   // Check that the flag for the parent's proxy to the child is reset
   // when the child navigates.
   main_test_rfh()->GetProcess()->sink().ClearMessages();
   FrameHostMsg_DidCommitProvisionalLoad_Params commit_params;
   commit_params.page_id = 0;
   commit_params.nav_entry_id = 0;
   commit_params.did_create_new_entry = false;
   commit_params.url = kUrl3;
   commit_params.transition = ui::PAGE_TRANSITION_AUTO_SUBFRAME;
   commit_params.should_update_history = false;
   commit_params.gesture = NavigationGestureAuto;
   commit_params.was_within_same_page = false;
   commit_params.method = "GET";
   commit_params.page_state = PageState::CreateFromURL(kUrl3);
-  commit_params.should_enforce_strict_mixed_content_checking = false;
+  commit_params.insecure_request_policy = blink::kLeaveInsecureRequestsAlone;
   child_host->SendNavigateWithParams(&commit_params);
-  EXPECT_NO_FATAL_FAILURE(CheckMixedContentIPC(
-      main_test_rfh(), false, proxy_to_parent->GetRoutingID()));
-  EXPECT_FALSE(root->child_at(0)
-                   ->current_replication_state()
-                   .should_enforce_strict_mixed_content_checking);
+  EXPECT_NO_FATAL_FAILURE(CheckInsecureRequestPolicyIPC(
+      main_test_rfh(), blink::kLeaveInsecureRequestsAlone,
+      proxy_to_parent->GetRoutingID()));
+  EXPECT_EQ(
+      blink::kLeaveInsecureRequestsAlone,
+      root->child_at(0)->current_replication_state().insecure_request_policy);
 }
 
 }  // namespace content