Expand SecurityStyleChanged interfaces to include explanations

chrome/browser/ui/browser_browsertest.cc

 // Copyright 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 <string>
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/compiler_specific.h"
 #include "base/files/file_path.h"
@@ skipping 74 matching lines @@
 #include "content/public/common/renderer_preferences.h"
 #include "content/public/common/url_constants.h"
 #include "content/public/test/browser_test_utils.h"
 #include "content/public/test/test_navigation_observer.h"
 #include "extensions/browser/extension_registry.h"
 #include "extensions/browser/extension_system.h"
 #include "extensions/browser/uninstall_reason.h"
 #include "extensions/common/constants.h"
 #include "extensions/common/extension.h"
 #include "extensions/common/extension_set.h"
+#include "net/base/net_errors.h"
 #include "net/dns/mock_host_resolver.h"
 #include "net/test/spawned_test_server/spawned_test_server.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/base/page_transition_types.h"
 
 #if defined(OS_MACOSX)
 #include "base/mac/scoped_nsautorelease_pool.h"
 #include "chrome/browser/ui/cocoa/run_loop_testing.h"
 #endif
 
@@ skipping 229 matching lines @@
     const net::HostPortPair& host_port_pair,
     std::string* replacement_path) {
   std::vector<net::SpawnedTestServer::StringPair> replacement_text;
   replacement_text.push_back(
       make_pair("REPLACE_WITH_HOST_AND_PORT", host_port_pair.ToString()));
   return net::SpawnedTestServer::GetFilePathWithReplacements(
       original_file_path, replacement_text, replacement_path);
 }
 
 // A WebContentsObserver useful for testing the SecurityStyleChanged()
-// method: it keeps track of the latest security style that was fired.
+// method: it keeps track of the latest security style and explanation
+// that was fired.
 class SecurityStyleTestObserver : public WebContentsObserver {
  public:
   explicit SecurityStyleTestObserver(content::WebContents* web_contents)
       : content::WebContentsObserver(web_contents),
         latest_security_style_(content::SECURITY_STYLE_UNKNOWN) {}
   ~SecurityStyleTestObserver() override {}
 
-  void SecurityStyleChanged(content::SecurityStyle security_style) override {
+  void SecurityStyleChanged(content::SecurityStyle security_style,
+                            const content::SecurityStyleExplanation&
+                                security_style_explanation) override {
     latest_security_style_ = security_style;
+    latest_security_style_explanation_ = security_style_explanation;
   }
 
   content::SecurityStyle latest_security_style() const {
     return latest_security_style_;
   }
 
+  const content::SecurityStyleExplanation& latest_security_style_explanation()

[Peter Kasting, 2015/06/16 06:29:11]

Nit: Prefer to break before the function name rather than before "const"

[estark, 2015/06/16 15:32:35]

Done.

+      const {
+    return latest_security_style_explanation_;
+  }
+
  private:
   content::SecurityStyle latest_security_style_;
+  content::SecurityStyleExplanation latest_security_style_explanation_;
 
   DISALLOW_COPY_AND_ASSIGN(SecurityStyleTestObserver);
 };
 
 }  // namespace
 
 class BrowserTest : public ExtensionBrowserTest {
  protected:
   // In RTL locales wrap the page title with RTL embedding characters so that it
   // matches the value returned by GetWindowTitle().
@@ skipping 2479 matching lines @@
   // Visit an (otherwise valid) HTTPS page that displays mixed content.
   std::string replacement_path;
   ASSERT_TRUE(GetFilePathWithHostAndPortReplacement(
       "files/ssl/page_displays_insecure_content.html",
       test_server()->host_port_pair(), &replacement_path));
 
   GURL mixed_content_url(https_test_server.GetURL(replacement_path));
   ui_test_utils::NavigateToURL(browser(), mixed_content_url);
   EXPECT_EQ(content::SECURITY_STYLE_WARNING, observer.latest_security_style());
 
+  const content::SecurityStyleExplanation& mixed_content_explanation =
+      observer.latest_security_style_explanation();
+  ASSERT_EQ(1u, mixed_content_explanation.warning_explanations.size());
+  EXPECT_EQ(l10n_util::GetStringUTF8(IDS_PASSIVE_MIXED_CONTENT),
+            mixed_content_explanation.warning_explanations[0].summary);
+  EXPECT_EQ(l10n_util::GetStringUTF8(IDS_PASSIVE_MIXED_CONTENT_DESCRIPTION),
+            mixed_content_explanation.warning_explanations[0].description);
+  EXPECT_EQ(0u, mixed_content_explanation.broken_explanations.size());
+
   // Visit a broken HTTPS url. Other conditions cannot be tested after
   // this one because once the interstitial is clicked through, all URLs
   // for this host will remain in a broken state.
   GURL expired_url(https_test_server_expired.GetURL(std::string()));
   ui_test_utils::NavigateToURL(browser(), expired_url);
 
   ProceedThroughInterstitial(web_contents);
   EXPECT_EQ(content::SECURITY_STYLE_AUTHENTICATION_BROKEN,
             observer.latest_security_style());
+
+  const content::SecurityStyleExplanation& expired_explanation =
+      observer.latest_security_style_explanation();
+  EXPECT_EQ(0u, expired_explanation.warning_explanations.size());
+  ASSERT_EQ(1u, expired_explanation.broken_explanations.size());
+  EXPECT_EQ(l10n_util::GetStringUTF8(IDS_CERTIFICATE_CHAIN_ERROR),
+            expired_explanation.broken_explanations[0].summary);
+  base::string16 error_string =
+      base::UTF8ToUTF16(net::ErrorToString(net::ERR_CERT_DATE_INVALID));
+  EXPECT_EQ(l10n_util::GetStringFUTF8(
+                IDS_CERTIFICATE_CHAIN_ERROR_DESCRIPTION_FORMAT, error_string),
+            expired_explanation.broken_explanations[0].description);
 }