Generalize WebContentsObserver::SecurityStyleChanged

chrome/browser/ssl/security_state_tab_helper_browser_tests.cc

 // Copyright 2015 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 "chrome/browser/ssl/security_state_tab_helper.h"
 
 #include "base/command_line.h"
 #include "base/files/file_path.h"
 #include "base/macros.h"
 #include "base/strings/string_split.h"
@@ skipping 45 matching lines @@
 #include "third_party/boringssl/src/include/openssl/ssl.h"
 #include "ui/base/l10n/l10n_util.h"
 
 namespace {
 
 enum CertificateStatus { VALID_CERTIFICATE, INVALID_CERTIFICATE };
 
 const base::FilePath::CharType kDocRoot[] =
     FILE_PATH_LITERAL("chrome/test/data");
 
-// A WebContentsObserver useful for testing the SecurityStyleChanged()
-// method: it keeps track of the latest security style and explanation
-// that was fired.
+// A WebContentsObserver useful for testing the DidChangeVisibleSecurityState()
+// method: it keeps track of the latest security style and explanation that was
+// fired.
 class SecurityStyleTestObserver : public content::WebContentsObserver {
  public:
   explicit SecurityStyleTestObserver(content::WebContents* web_contents)
       : content::WebContentsObserver(web_contents),
         latest_security_style_(blink::WebSecurityStyleUnknown) {}
   ~SecurityStyleTestObserver() override {}
 
-  void SecurityStyleChanged(blink::WebSecurityStyle security_style,
-                            const content::SecurityStyleExplanations&
-                                security_style_explanations) override {
-    latest_security_style_ = security_style;
-    latest_explanations_ = security_style_explanations;
+  void DidChangeVisibleSecurityState() override {
+    content::SecurityStyleExplanations explanations;
+    latest_security_style_ = web_contents()->GetDelegate()->GetSecurityStyle(
+        web_contents(), &explanations);
+    latest_explanations_ = explanations;
   }
 
   blink::WebSecurityStyle latest_security_style() const {
     return latest_security_style_;
   }
 
   const content::SecurityStyleExplanations& latest_explanations() const {
     return latest_explanations_;
   }
 
@@ skipping 245 matching lines @@
       command_line->AppendSwitchASCII(
           security_state::switches::kMarkHttpAs,
           security_state::switches::kMarkHttpWithPasswordsOrCcWithChip);
     }
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(SecurityStateTabHelperTestWithPasswordCcSwitch);
 };
 
-class SecurityStyleChangedTest : public InProcessBrowserTest {
+class DidChangeVisibleSecurityStateTest : public InProcessBrowserTest {
  public:
-  SecurityStyleChangedTest()
+  DidChangeVisibleSecurityStateTest()
       : https_server_(net::EmbeddedTestServer::TYPE_HTTPS) {
     https_server_.ServeFilesFromSourceDirectory(base::FilePath(kDocRoot));
   }
 
   void SetUpCommandLine(base::CommandLine* command_line) override {
     // Browser will both run and display insecure content.
     command_line->AppendSwitch(switches::kAllowRunningInsecureContent);
   }
 
  protected:
   net::EmbeddedTestServer https_server_;
 
  private:
-  DISALLOW_COPY_AND_ASSIGN(SecurityStyleChangedTest);
+  DISALLOW_COPY_AND_ASSIGN(DidChangeVisibleSecurityStateTest);
 };
 
 IN_PROC_BROWSER_TEST_F(SecurityStateTabHelperTest, HttpPage) {
   ASSERT_TRUE(embedded_test_server()->Start());
   ui_test_utils::NavigateToURL(
       browser(), embedded_test_server()->GetURL("/ssl/google.html"));
   content::WebContents* contents =
       browser()->tab_strip_model()->GetActiveWebContents();
   ASSERT_TRUE(contents);
 
@@ skipping 1132 matching lines @@
                              false /* expect cert status error */);
 
   browser()->tab_strip_model()->InsertWebContentsAt(0, new_contents,
                                                     TabStripModel::ADD_NONE);
   CheckSecurityInfoForSecure(new_contents, security_state::SECURE,
                              security_state::NO_DEPRECATED_SHA1,
                              security_state::CONTENT_STATUS_NONE, false,
                              false /* expect cert status error */);
 }
 
-// Tests that the WebContentsObserver::SecurityStyleChanged event fires
+// Tests that the WebContentsObserver::DidChangeVisibleSecurityState event fires
 // with the current style on HTTP, broken HTTPS, and valid HTTPS pages.
-IN_PROC_BROWSER_TEST_F(SecurityStyleChangedTest, SecurityStyleChangedObserver) {
+IN_PROC_BROWSER_TEST_F(DidChangeVisibleSecurityStateTest,
+                       DidChangeVisibleSecurityStateObserver) {
   ASSERT_TRUE(https_server_.Start());
   ASSERT_TRUE(embedded_test_server()->Start());
 
   net::EmbeddedTestServer https_test_server_expired(
       net::EmbeddedTestServer::TYPE_HTTPS);
   https_test_server_expired.SetSSLConfig(net::EmbeddedTestServer::CERT_EXPIRED);
   https_test_server_expired.ServeFilesFromSourceDirectory(
       base::FilePath(kDocRoot));
   ASSERT_TRUE(https_test_server_expired.Start());
 
@@ skipping 115 matching lines @@
   EXPECT_FALSE(observer.latest_explanations().pkp_bypassed);
   EXPECT_TRUE(observer.latest_explanations().info_explanations.empty());
   EXPECT_FALSE(observer.latest_explanations().displayed_mixed_content);
   EXPECT_FALSE(observer.latest_explanations().ran_mixed_content);
 }
 
 // Visit a valid HTTPS page, then a broken HTTPS page, and then go back,
 // and test that the observed security style matches.
 #if defined(OS_CHROMEOS)
 // Flaky on Chrome OS. See https://crbug.com/638576.
-#define MAYBE_SecurityStyleChangedObserverGoBack \
-  DISABLED_SecurityStyleChangedObserverGoBack
+#define MAYBE_DidChangeVisibleSecurityStateObserverGoBack \
+  DISABLED_DidChangeVisibleSecurityStateObserverGoBack
 #else
-#define MAYBE_SecurityStyleChangedObserverGoBack \
-  SecurityStyleChangedObserverGoBack
+#define MAYBE_DidChangeVisibleSecurityStateObserverGoBack \
+  DidChangeVisibleSecurityStateObserverGoBack
 #endif
-IN_PROC_BROWSER_TEST_F(SecurityStyleChangedTest,
-                       MAYBE_SecurityStyleChangedObserverGoBack) {
+IN_PROC_BROWSER_TEST_F(DidChangeVisibleSecurityStateTest,
+                       MAYBE_DidChangeVisibleSecurityStateObserverGoBack) {
   ASSERT_TRUE(https_server_.Start());
 
   net::EmbeddedTestServer https_test_server_expired(
       net::EmbeddedTestServer::TYPE_HTTPS);
   https_test_server_expired.SetSSLConfig(net::EmbeddedTestServer::CERT_EXPIRED);
   https_test_server_expired.ServeFilesFromSourceDirectory(
       base::FilePath(kDocRoot));
   ASSERT_TRUE(https_test_server_expired.Start());
 
   content::WebContents* web_contents =
@@ skipping 178 matching lines @@
 
  private:
   scoped_refptr<net::X509Certificate> cert_;
 
   DISALLOW_COPY_AND_ASSIGN(BrowserTestNonsecureURLRequest);
 };
 
 // Tests that a connection with obsolete TLS settings does not get a
 // secure connection explanation.
 IN_PROC_BROWSER_TEST_F(BrowserTestNonsecureURLRequest,
-                       SecurityStyleChangedObserverNonsecureConnection) {
+                       DidChangeVisibleSecurityStateObserverNonsecureConnection) {
   content::WebContents* web_contents =
       browser()->tab_strip_model()->GetActiveWebContents();
   SecurityStyleTestObserver observer(web_contents);
 
   ui_test_utils::NavigateToURL(
       browser(), GURL(std::string("https://") + kMockNonsecureHostname));
 
   // The security style of the page doesn't get downgraded for obsolete
   // TLS settings, so it should remain at WebSecurityStyleAuthenticated.
   EXPECT_EQ(blink::WebSecurityStyleAuthenticated,
@@ skipping 161 matching lines @@
   SecurityStateTabHelper* helper =
       SecurityStateTabHelper::FromWebContents(web_contents);
   ASSERT_TRUE(helper);
   security_state::SecurityInfo security_info;
   helper->GetSecurityInfo(&security_info);
   EXPECT_EQ(security_state::SECURE, security_info.security_level);
   EXPECT_EQ(kTestSCTStatuses, security_info.sct_verify_statuses);
 }
 
 }  // namespace