Downgrade page security if an inline has invalid certificate.

chrome/browser/ssl/ssl_browser_tests.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/command_line.h"
 #include "base/path_service.h"
 #include "base/prefs/pref_service.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
@@ skipping 1058 matching lines @@
   WebContents* tab = browser()->tab_strip_model()->GetActiveWebContents();
   CheckUnauthenticatedState(tab);
 
   // Load again but over SSL.  It should be marked as displaying insecure
   // content (even though the image comes from the WebCore memory cache).
   const GURL url_https = https_server_.GetURL(replacement_path);
   ui_test_utils::NavigateToURL(browser(), url_https);
   CheckAuthenticationBrokenState(tab, 0, true, false);
 }
 
+IN_PROC_BROWSER_TEST_F(SSLUITest, TestDisplaysInlineUsingInvalidCertificate) {
+  ASSERT_TRUE(https_server_mismatched_.Start());
+  ASSERT_TRUE(https_server_.Start());
+
+  // Load the image using insecure server.
+  GURL url(https_server_mismatched_.GetURL("files/ssl/google_files/logo.gif"));
+  ui_test_utils::NavigateToURL(browser(), url);
+
+  WebContents* tab = browser()->tab_strip_model()->GetActiveWebContents();
+  CheckAuthenticationBrokenState(
+      tab, net::CERT_STATUS_COMMON_NAME_INVALID, false, true);
+  ProceedThroughInterstitial(tab);
+  CheckAuthenticationBrokenState(
+      tab, net::CERT_STATUS_COMMON_NAME_INVALID, false, false);
+
+  // Load the webpage using secure server.
+  std::string replacement_path;
+  ASSERT_TRUE(GetFilePathWithHostAndPortReplacement(
+      "files/ssl/page_with_dynamic_insecure_content.html",
+      https_server_mismatched_.host_port_pair(),
+      &replacement_path));
+  ui_test_utils::NavigateToURL(browser(),
+                               https_server_.GetURL(replacement_path));
+  CheckAuthenticatedState(tab, false);
+  EXPECT_FALSE(tab->DisplayedInsecureContent());
+
+  // Load the inline image using insecure server.
+  bool js_result = false;
+  EXPECT_TRUE(content::ExecuteScriptAndExtractBool(
+      tab, "loadBadImage('https');", &js_result));
+  EXPECT_TRUE(js_result);
+
+  // Page security should be downgraded.
+  CheckAuthenticatedState(tab, true);
+  EXPECT_TRUE(tab->DisplayedInsecureContent());
+}

[Ryan Sleevi, 2014/03/11 01:39:39]

Can you add an additional test to test for 'intranet' names, so that we can make
sure the behaviour is as expected?

On internal host names, we don't force an interstitial, but do degrade the UI.
Ideally, we'd propagate that brokenness (eg: if good.com included a resource
from myinternalhost.invalid)

We can accomplish this with a MockCertVerifier (to set the desired status for
given certificate/hostnames) and a RuleBasedHostResolverProc (IIRC)

+
 // This test ensures the CN invalid status does not 'stick' to a certificate
 // (see bug #1044942) and that it depends on the host-name.
 IN_PROC_BROWSER_TEST_F(SSLUITest, TestCNInvalidStickiness) {
   ASSERT_TRUE(https_server_.Start());
   ASSERT_TRUE(https_server_mismatched_.Start());
 
   // First we hit the server with hostname, this generates an invalid policy
   // error.
   ui_test_utils::NavigateToURL(browser(),
       https_server_mismatched_.GetURL("files/ssl/google.html"));
@@ skipping 581 matching lines @@
 
 // Visit a page over https that contains a frame with a redirect.
 
 // XMLHttpRequest insecure content in synchronous mode.
 
 // XMLHttpRequest insecure content in asynchronous mode.
 
 // XMLHttpRequest over bad ssl in synchronous mode.
 
 // XMLHttpRequest over OK ssl in synchronous mode.