Add experimental versions of the SSL interstitial

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/command_line.h"
 #include "base/i18n/rtl.h"
 #include "base/metrics/field_trial.h"
 #include "base/metrics/histogram.h"
@@ skipping 39 matching lines @@
 #endif
 
 using base::ASCIIToUTF16;
 using base::TimeTicks;
 using content::InterstitialPage;
 using content::NavigationController;
 using content::NavigationEntry;
 
 namespace {
 
+// Constants for the M37 Finch trial.
+const char kInterstitialTrialName[] = "SSLInterstitialVersion";
+const char kCondV1[] = "V1";
+const char kCondV1LayoutV2Text[] = "V1LayoutV2Text";
+const char kCondV2[] = "V2";  // Also the default.
+const char kCondV2Guard[] = "V2WithGuard";
+const char kCondV2Yellow[] = "V2Yellow";
+
+const char* GetTrialCondition() {

[Dan Beam, 2014/06/20 21:28:20]

nit: makes the code smaller and easier to read

  CommandLine* cli = CommandLine::ForCurrentProcess();
  std::string name(base::FieldTrialList::FindFullName(kInterstitialTrialName));

  if (cli->HasSwitch(switches::kSSLInterstitialV1) || name == kConvV1)
    return kCondV1;

[felt, 2014/06/21 00:23:16]

Done.

+  if (CommandLine::ForCurrentProcess()->HasSwitch(
+          switches::kSSLInterstitialV1) ||
+      base::FieldTrialList::FindFullName(kInterstitialTrialName) == kCondV1) {
+    return kCondV1;
+  }
+  if (CommandLine::ForCurrentProcess()->HasSwitch(
+          switches::kSSLInterstitialV2) ||
+      base::FieldTrialList::FindFullName(kInterstitialTrialName) == kCondV2) {
+    return kCondV2;
+  }
+  if (CommandLine::ForCurrentProcess()->HasSwitch(
+          switches::kSSLInterstitialV1WithV2Text) ||
+      base::FieldTrialList::FindFullName(kInterstitialTrialName)
+          == kCondV1LayoutV2Text) {
+    return kCondV1LayoutV2Text;
+  }
+  if (CommandLine::ForCurrentProcess()->HasSwitch(
+          switches::kSSLInterstitialV2Guard) ||
+      base::FieldTrialList::FindFullName(kInterstitialTrialName)
+          == kCondV2Guard) {
+    return kCondV2Guard;
+  }
+  if (CommandLine::ForCurrentProcess()->HasSwitch(
+          switches::kSSLInterstitialV2Yellow) ||
+      base::FieldTrialList::FindFullName(kInterstitialTrialName)
+          == kCondV2Yellow) {
+    return kCondV2Yellow;
+  }
+  return kCondV2;
+}
+
 // Events for UMA. Do not reorder or change!
 enum SSLBlockingPageEvent {
   SHOW_ALL,
   SHOW_OVERRIDABLE,
   PROCEED_OVERRIDABLE,
   PROCEED_NAME,
   PROCEED_DATE,
   PROCEED_AUTHORITY,
   DONT_PROCEED_OVERRIDABLE,
   DONT_PROCEED_NAME,
@@ skipping 123 matching lines @@
       cert_error_(cert_error),
       ssl_info_(ssl_info),
       request_url_(request_url),
       overridable_(overridable),
       strict_enforcement_(strict_enforcement),
       internal_(false),
       num_visits_(-1),
       captive_portal_detection_enabled_(false),
       captive_portal_probe_completed_(false),
       captive_portal_no_response_(false),
-      captive_portal_detected_(false) {
+      captive_portal_detected_(false),
+      trial_condition_(GetTrialCondition()) {
   Profile* profile = Profile::FromBrowserContext(
       web_contents->GetBrowserContext());
   // For UMA stats.
   if (net::IsHostnameNonUnique(request_url_.HostNoBrackets()))
     internal_ = true;
   RecordSSLBlockingPageEventStats(SHOW_ALL);
   if (overridable_ && !strict_enforcement_) {
     RecordSSLBlockingPageEventStats(SHOW_OVERRIDABLE);
     if (internal_)
       RecordSSLBlockingPageEventStats(SHOW_INTERNAL_HOSTNAME);
@@ skipping 34 matching lines @@
                                        captive_portal_probe_completed_,
                                        captive_portal_no_response_,
                                        captive_portal_detected_);
     // The page is closed without the user having chosen what to do, default to
     // deny.
     NotifyDenyCertificate();
   }
 }
 
 std::string SSLBlockingPage::GetHTMLContents() {
-  if (CommandLine::ForCurrentProcess()->HasSwitch(
-          switches::kSSLInterstitialVersionV1) ||
-      base::FieldTrialList::FindFullName("SSLInterstitialVersion") == "V1") {
+  if (trial_condition_ == kCondV1 || trial_condition_ == kCondV1LayoutV2Text)
     return GetHTMLContentsV1();
-  }
   return GetHTMLContentsV2();
 }
 
 std::string SSLBlockingPage::GetHTMLContentsV1() {
   base::DictionaryValue strings;
   int resource_id;
   if (overridable_ && !strict_enforcement_) {
     // Let's build the overridable error page.
     SSLErrorInfo error_info =
         SSLErrorInfo::CreateError(
             SSLErrorInfo::NetErrorToErrorType(cert_error_),
             ssl_info_.cert.get(),
             request_url_);
+    resource_id = IDR_SSL_ROAD_BLOCK_HTML;
+    strings.SetString("textdirection", base::i18n::IsRTL() ? "rtl" : "ltr");
+    strings.SetString("errorType", "overridable");
+    if (trial_condition_ == kCondV1LayoutV2Text) {
+      base::string16 url(ASCIIToUTF16(request_url_.host()));
+      strings.SetString(
+          "headLine", l10n_util::GetStringUTF16(IDS_SSL_V2_HEADING));
+      strings.SetString(
+          "description",
+          l10n_util::GetStringFUTF16(IDS_SSL_V2_PRIMARY_PARAGRAPH, url));
+      strings.SetString(
+          "moreInfoTitle",
+          l10n_util::GetStringUTF16(IDS_SSL_V2_OPEN_DETAILS_BUTTON));
+      strings.SetString("moreInfo1", error_info.details());
+      strings.SetString("moreInfo2", std::string());
+      strings.SetString("moreInfo3", std::string());
+      strings.SetString("moreInfo4", std::string());
+      strings.SetString("moreInfo5", std::string());

[Dan Beam, 2014/06/20 21:28:20]

^ don't these need to be base::string16()?

[felt, 2014/06/21 00:23:15]

Done, although it doesn't really matter for the empty string I think?

+      strings.SetString(
+          "exit",
+          l10n_util::GetStringUTF16(IDS_SSL_OVERRIDABLE_SAFETY_BUTTON));
+      strings.SetString(
+          "title", l10n_util::GetStringUTF16(IDS_SSL_V2_TITLE));
+      strings.SetString(
+          "proceed",
+          l10n_util::GetStringUTF16(IDS_SSL_OVERRIDABLE_PROCEED_LINK_TEXT));
+      strings.SetString(
+          "reasonForNotProceeding", std::string());
+    } else {
+      strings.SetString("headLine", error_info.title());
+      strings.SetString("description", error_info.details());
+      strings.SetString("moreInfoTitle",
+          l10n_util::GetStringUTF16(IDS_CERT_ERROR_EXTRA_INFO_TITLE));
+      SetExtraInfo(&strings, error_info.extra_information());
 
-    resource_id = IDR_SSL_ROAD_BLOCK_HTML;
-    strings.SetString("headLine", error_info.title());
-    strings.SetString("description", error_info.details());
-    strings.SetString("moreInfoTitle",
-        l10n_util::GetStringUTF16(IDS_CERT_ERROR_EXTRA_INFO_TITLE));
-    SetExtraInfo(&strings, error_info.extra_information());
-
-    strings.SetString(
-        "exit", l10n_util::GetStringUTF16(IDS_SSL_OVERRIDABLE_PAGE_EXIT));
-    strings.SetString(
-        "title", l10n_util::GetStringUTF16(IDS_SSL_OVERRIDABLE_PAGE_TITLE));
-    strings.SetString(
-        "proceed", l10n_util::GetStringUTF16(IDS_SSL_OVERRIDABLE_PAGE_PROCEED));
-    strings.SetString(
-        "reasonForNotProceeding", l10n_util::GetStringUTF16(
-            IDS_SSL_OVERRIDABLE_PAGE_SHOULD_NOT_PROCEED));
-    strings.SetString("errorType", "overridable");
-    strings.SetString("textdirection", base::i18n::IsRTL() ? "rtl" : "ltr");
+      strings.SetString(
+          "exit", l10n_util::GetStringUTF16(IDS_SSL_OVERRIDABLE_PAGE_EXIT));
+      strings.SetString(
+          "title", l10n_util::GetStringUTF16(IDS_SSL_OVERRIDABLE_PAGE_TITLE));
+      strings.SetString(
+          "proceed",
+          l10n_util::GetStringUTF16(IDS_SSL_OVERRIDABLE_PAGE_PROCEED));
+      strings.SetString(
+          "reasonForNotProceeding", l10n_util::GetStringUTF16(
+              IDS_SSL_OVERRIDABLE_PAGE_SHOULD_NOT_PROCEED));

[Dan Beam, 2014/06/20 21:28:20]

opt nit:

  strings.SetString("reasonForNotProceeding",
      l10n_util::GetStringUTF16(IDS_SSL_OVERRIDABLE_PAGE_SHOULD_NOT_PROCEED));

[felt, 2014/06/21 00:23:15]

sure

+    }
   } else {
     // Let's build the blocking error page.
     resource_id = IDR_SSL_BLOCKING_HTML;
 
     // Strings that are not dependent on the URL.
     strings.SetString(
         "title", l10n_util::GetStringUTF16(IDS_SSL_BLOCKING_PAGE_TITLE));
     strings.SetString(
         "reloadMsg", l10n_util::GetStringUTF16(IDS_ERRORPAGES_BUTTON_RELOAD));
     strings.SetString(
@@ skipping 100 matching lines @@
           resource_id));
   return webui::GetI18nTemplateHtml(html, &strings);
 }
 
 std::string SSLBlockingPage::GetHTMLContentsV2() {
   base::DictionaryValue load_time_data;
   base::string16 url(ASCIIToUTF16(request_url_.host()));
   if (base::i18n::IsRTL())
     base::i18n::WrapStringWithLTRFormatting(&url);
   webui::SetFontAndTextDirection(&load_time_data);
+  load_time_data.SetString("trialCondition", trial_condition_);
 
   // Shared values for both the overridable and non-overridable versions.
   load_time_data.SetBoolean("ssl", true);
   load_time_data.SetBoolean(
       "overridable", overridable_ && !strict_enforcement_);
   load_time_data.SetString(
       "tabTitle", l10n_util::GetStringUTF16(IDS_SSL_V2_TITLE));
   load_time_data.SetString(
       "heading", l10n_util::GetStringUTF16(IDS_SSL_V2_HEADING));
   load_time_data.SetString(
@@ skipping 212 matching lines @@
     // sure we don't clear the captive portal flag, since the interstitial was
     // potentially caused by the captive portal.
     captive_portal_detected_ = captive_portal_detected_ ||
         (results->result == captive_portal::RESULT_BEHIND_CAPTIVE_PORTAL);
     // Also keep track of non-HTTP portals and error cases.
     captive_portal_no_response_ = captive_portal_no_response_ ||
         (results->result == captive_portal::RESULT_NO_RESPONSE);
   }
 #endif
 }