Common Name Mismatch Handler For WWW Subdomain Mismatch case

chrome/browser/ssl/ssl_blocking_page.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 "chrome/browser/ssl/ssl_blocking_page.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/build_time.h"
 #include "base/callback_helpers.h"
@@ skipping 219 matching lines @@
 
 // Note that we always create a navigation entry with SSL errors.
 // No error happening loading a sub-resource triggers an interstitial so far.
 SSLBlockingPage::SSLBlockingPage(content::WebContents* web_contents,
                                  int cert_error,
                                  const net::SSLInfo& ssl_info,
                                  const GURL& request_url,
                                  int options_mask,
                                  const base::Time& time_triggered,
                                  scoped_ptr<SSLCertReporter> ssl_cert_reporter,
-                                 const base::Callback<void(bool)>& callback)
+                                 const base::Callback<void(bool)>& callback,
+                                 const GURL& suggested_url)
     : SecurityInterstitialPage(web_contents, request_url),
       callback_(callback),
       cert_error_(cert_error),
       ssl_info_(ssl_info),
       overridable_(IsOverridable(
           options_mask,
           Profile::FromBrowserContext(web_contents->GetBrowserContext()))),
       danger_overridable_(DoesPolicyAllowDangerOverride(
           Profile::FromBrowserContext(web_contents->GetBrowserContext()))),
       strict_enforcement_((options_mask & STRICT_ENFORCEMENT) != 0),
       expired_but_previously_allowed_(
           (options_mask & EXPIRED_BUT_PREVIOUSLY_ALLOWED) != 0),
-      time_triggered_(time_triggered) {
+      time_triggered_(time_triggered),
+      suggested_url_(suggested_url) {
   interstitial_reason_ =
       IsErrorDueToBadClock(time_triggered_, cert_error_) ?
       SSL_REASON_BAD_CLOCK : SSL_REASON_SSL;
 
   // We collapse the Rappor metric name to just "ssl" so we don't leak
   // the "overridable" bit.  We skip Rappor altogether for bad clocks.
   // This must be done after calculating |interstitial_reason_| above.
   set_metrics_helper(new SecurityInterstitialMetricsHelper(
       web_contents, request_url, GetUmaHistogramPrefix(), kSSLRapporPrefix,
       (interstitial_reason_ == SSL_REASON_BAD_CLOCK
@@ skipping 119 matching lines @@
         l10n_util::GetStringFUTF16(IDS_SSL_V2_PRIMARY_PARAGRAPH, url));
 
     if (overridable_) {
       load_time_data->SetBoolean("overridable", true);
 
       SSLErrorInfo error_info =
           SSLErrorInfo::CreateError(
               SSLErrorInfo::NetErrorToErrorType(cert_error_),
               ssl_info_.cert.get(),
               request_url());
+
+      // If suggested url is not empty, display a modified message
+      // with a link to suggested_url.
+      if (!suggested_url_.is_empty()) {
+        load_time_data->SetString(
+        "primaryParagraph",
+        l10n_util::GetStringFUTF16(
+            IDS_SSL_COMMON_NAME_MISMATCH_PRIMARY_PARAGRAPH,
+            base::UTF8ToUTF16(request_url().host()),
+            base::UTF8ToUTF16(suggested_url_.host()),
+            base::UTF8ToUTF16(suggested_url_.spec())));
+      }
+
       load_time_data->SetString("explanationParagraph", error_info.details());
       load_time_data->SetString(
           "primaryButtonText",
           l10n_util::GetStringUTF16(IDS_SSL_OVERRIDABLE_SAFETY_BUTTON));
       load_time_data->SetString(
           "finalParagraph",
           l10n_util::GetStringFUTF16(IDS_SSL_OVERRIDABLE_PROCEED_PARAGRAPH,
                                    url));
     } else {
       load_time_data->SetBoolean("overridable", false);
@@ skipping 242 matching lines @@
       !(options_mask & SSLBlockingPage::STRICT_ENFORCEMENT) &&
       profile->GetPrefs()->GetBoolean(prefs::kSSLErrorOverrideAllowed);
   return is_overridable;
 }
 
 // static
 bool SSLBlockingPage::DoesPolicyAllowDangerOverride(
     const Profile* const profile) {
   return profile->GetPrefs()->GetBoolean(prefs::kSSLErrorOverrideAllowed);
 }