Add experimental versions of the malware interstitial

chrome/browser/safe_browsing/safe_browsing_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.
 //
 // Implementation of the SafeBrowsingBlockingPage class.
 
 #include "chrome/browser/safe_browsing/safe_browsing_blocking_page.h"
 
 #include <string>
 
@@ skipping 99 matching lines @@
 // RecordUserReactionTime.
 const char kNavigatedAwayMetaCommand[] = "closed";
 
 // Other constants used to communicate with the JavaScript.
 const char kBoxChecked[] = "boxchecked";
 const char kDisplayCheckBox[] = "displaycheckbox";
 
 base::LazyInstance<SafeBrowsingBlockingPage::UnsafeResourceMap>
     g_unsafe_resource_map = LAZY_INSTANCE_INITIALIZER;
 
-// These are the conditions for the summer 2013 Finch experiment.
-// TODO(felt): Get rid of these now that experiment has ended.
-const char kMalwareStudyName[] = "InterstitialMalware310";
-const char kPhishingStudyName[] = "InterstitialPhishing564";
-const char kCond7MalwareFearMsg[] = "cond7MalwareFearMsg";
-const char kCond8PhishingFearMsg[] = "cond8PhishingFearMsg";
-const char kCond9MalwareCollabMsg[] = "cond9MalwareCollabMsg";
-const char kCond10PhishingCollabMsg[] = "cond10PhishingCollabMsg";
-const char kCond11MalwareQuestion[] = "cond11MalwareQuestion";
-const char kCond12PhishingQuestion[] = "cond12PhishingQuestion";
-const char kCond13MalwareGoBack[] = "cond13MalwareGoBack";
-const char kCond14PhishingGoBack[] = "cond14PhishingGoBack";
-
 // This enum is used for a histogram.  Don't reorder, delete, or insert
 // elements.  New elements should be added before MAX_ACTION only.
 enum DetailedDecision {
   MALWARE_SHOW_NEW_SITE = 0,
   MALWARE_PROCEED_NEW_SITE,
   MALWARE_SHOW_CROSS_SITE,
   MALWARE_PROCEED_CROSS_SITE,
   PHISHING_SHOW_NEW_SITE,
   PHISHING_PROCEED_NEW_SITE,
   PHISHING_SHOW_CROSS_SITE,
   PHISHING_PROCEED_CROSS_SITE,
   MAX_DETAILED_ACTION
 };
 
 void RecordDetailedUserAction(DetailedDecision decision) {
   UMA_HISTOGRAM_ENUMERATION("SB2.InterstitialActionDetails",
                             decision,
                             MAX_DETAILED_ACTION);
 }
 
-// These are the constants for the M37 Finch trial.
-const char kV3StudyName[] = "MalwareInterstitialVersion";
-const char kCondUseV2[] = "V2";
+// Constants for the M37 Finch trial.
+const char kV3StudyName[]         = "MalwareInterstitialVersion";
+const char kCondV2[]              = "V2";
+const char kCondV3[]              = "V3";
+const char kCondV3Advice[]        = "V3Advice";
+const char kCondV3Social[]        = "V3Social";
+const char kCondV3NotRecommend[]  = "V3NotRecommend";
+const char kCondV3History[]       = "V3History";
 
 // Default to V3 unless a flag or field trial says otherwise.
-bool Version3Enabled() {
+const char* GetTrialCondition() {
   if (CommandLine::ForCurrentProcess()->HasSwitch(
-      switches::kMalwareInterstitialVersionV2)) {
-    return false;
+          switches::kMalwareInterstitialV2) ||
+      base::FieldTrialList::FindFullName(kV3StudyName) == kCondV2) {

[mattm, 2014/06/19 06:57:03]

Seems like the switches should always override the field trial

[felt, 2014/06/19 14:08:54]

Done.

+    return kCondV2;
   }
-  if (base::FieldTrialList::FindFullName(kV3StudyName) == kCondUseV2)
-    return false;
-  return true;
+  if (CommandLine::ForCurrentProcess()->HasSwitch(
+          switches::kMalwareInterstitialV3) ||
+      base::FieldTrialList::FindFullName(kV3StudyName) == kCondV3) {
+    return kCondV3;
+  }
+  if (CommandLine::ForCurrentProcess()->HasSwitch(
+          switches::kMalwareInterstitialV3Advice) ||
+      base::FieldTrialList::FindFullName(kV3StudyName) == kCondV3Advice) {
+    return kCondV3Advice;
+  }
+  if (CommandLine::ForCurrentProcess()->HasSwitch(
+          switches::kMalwareInterstitialV3Social) ||
+      base::FieldTrialList::FindFullName(kV3StudyName) == kCondV3Social) {
+    return kCondV3Social;
+  }
+  if (CommandLine::ForCurrentProcess()->HasSwitch(
+          switches::kMalwareInterstitialV3NotRecommend) ||
+      base::FieldTrialList::FindFullName(kV3StudyName) == kCondV3NotRecommend) {
+    return kCondV3NotRecommend;
+  }
+  if (CommandLine::ForCurrentProcess()->HasSwitch(
+          switches::kMalwareInterstitialV3History) ||
+      base::FieldTrialList::FindFullName(kV3StudyName) == kCondV3History) {
+    return kCondV3History;
+  }
+  return kCondV3;
 }
 
 }  // namespace
 
 // static
 SafeBrowsingBlockingPageFactory* SafeBrowsingBlockingPage::factory_ = NULL;
 
 // The default SafeBrowsingBlockingPageFactory.  Global, made a singleton so we
 // don't leak it.
 class SafeBrowsingBlockingPageFactoryImpl
     : public SafeBrowsingBlockingPageFactory {
  public:
   virtual SafeBrowsingBlockingPage* CreateSafeBrowsingPage(
       SafeBrowsingUIManager* ui_manager,
       WebContents* web_contents,
       const SafeBrowsingBlockingPage::UnsafeResourceList& unsafe_resources)
       OVERRIDE {
     // Only use the V2 page if the interstitial is for a single malware or
     // phishing resource, the multi-threat interstitial has not been updated to
     // V2 yet.
     if (unsafe_resources.size() == 1 &&
         (unsafe_resources[0].threat_type == SB_THREAT_TYPE_URL_MALWARE ||
          unsafe_resources[0].threat_type ==
          SB_THREAT_TYPE_CLIENT_SIDE_MALWARE_URL ||
          unsafe_resources[0].threat_type == SB_THREAT_TYPE_URL_PHISHING ||
          unsafe_resources[0].threat_type ==
          SB_THREAT_TYPE_CLIENT_SIDE_PHISHING_URL)) {
-      if (Version3Enabled()) {
-        return new SafeBrowsingBlockingPageV3(ui_manager, web_contents,
+      if (GetTrialCondition() == kCondV2) {
+        return new SafeBrowsingBlockingPageV2(ui_manager, web_contents,
             unsafe_resources);
       } else {
-        return new SafeBrowsingBlockingPageV2(ui_manager, web_contents,
+        return new SafeBrowsingBlockingPageV3(ui_manager, web_contents,
             unsafe_resources);
       }
     }
     return new SafeBrowsingBlockingPageV1(ui_manager, web_contents,
                                           unsafe_resources);
   }
 
  private:
   friend struct base::DefaultLazyInstanceTraits<
       SafeBrowsingBlockingPageFactoryImpl>;
@@ skipping 826 matching lines @@
 void SafeBrowsingBlockingPageV1::PopulatePhishingStringDictionary(
     base::DictionaryValue* strings) {
   NOTREACHED();
 }
 
 SafeBrowsingBlockingPageV2::SafeBrowsingBlockingPageV2(
     SafeBrowsingUIManager* ui_manager,
     WebContents* web_contents,
     const UnsafeResourceList& unsafe_resources)
   : SafeBrowsingBlockingPage(ui_manager, web_contents, unsafe_resources) {
-    if (unsafe_resources_[0].threat_type == SB_THREAT_TYPE_URL_MALWARE ||
-        unsafe_resources_[0].threat_type ==
-        SB_THREAT_TYPE_CLIENT_SIDE_MALWARE_URL) {
-      trialCondition_ =
-          base::FieldTrialList::FindFullName(kMalwareStudyName);
-    } else if (unsafe_resources_[0].threat_type ==
-                   SB_THREAT_TYPE_URL_PHISHING ||
-               unsafe_resources_[0].threat_type ==
-                   SB_THREAT_TYPE_CLIENT_SIDE_PHISHING_URL) {
-      trialCondition_ =
-          base::FieldTrialList::FindFullName(kPhishingStudyName);
-    }
 }
 
 std::string SafeBrowsingBlockingPageV2::GetHTMLContents() {
   // Load the HTML page and create the template components.
   base::DictionaryValue strings;
   ResourceBundle& rb = ResourceBundle::GetSharedInstance();
   std::string html;
 
   if (unsafe_resources_.empty()) {
     NOTREACHED();
@@ skipping 37 matching lines @@
                       IsPrefEnabled(prefs::kSafeBrowsingProceedAnywayDisabled));
   strings->SetBoolean("isMainFrame", is_main_frame_load_blocked_);
   strings->SetBoolean("isPhishing", interstitial_type_ == TYPE_PHISHING);
 
   strings->SetString("back_button",
       l10n_util::GetStringUTF16(IDS_SAFE_BROWSING_MALWARE_BACK_BUTTON));
   strings->SetString("seeMore", l10n_util::GetStringUTF16(
       IDS_SAFE_BROWSING_MALWARE_V2_SEE_MORE));
   strings->SetString("proceed",
       l10n_util::GetStringUTF16(IDS_SAFE_BROWSING_MALWARE_V2_PROCEED_LINK));
-
-  // Field trial
-  strings->SetString("trialType", trialCondition_);
-  if (trialCondition_ == kCond7MalwareFearMsg) {
-    strings->SetString("headLine",
-        l10n_util::GetStringUTF16(IDS_SAFE_BROWSING_MALWARE_FEAR_HEADLINE));
-  } else if (trialCondition_ == kCond8PhishingFearMsg) {
-    strings->SetString("headLine",
-        l10n_util::GetStringUTF16(IDS_SAFE_BROWSING_PHISHING_FEAR_HEADLINE));
-  } else if (trialCondition_ == kCond9MalwareCollabMsg) {
-    strings->SetString("headLine",
-        l10n_util::GetStringUTF16(IDS_SAFE_BROWSING_MALWARE_COLLAB_HEADLINE));
-  } else if (trialCondition_ == kCond10PhishingCollabMsg) {
-    strings->SetString("headLine",
-        l10n_util::GetStringUTF16(IDS_SAFE_BROWSING_PHISHING_COLLAB_HEADLINE));
-  } else if (trialCondition_ == kCond11MalwareQuestion) {
-    strings->SetString("headLine",
-        l10n_util::GetStringUTF16(IDS_SAFE_BROWSING_MALWARE_QUESTION_HEADLINE));
-  } else if (trialCondition_ == kCond12PhishingQuestion) {
-    strings->SetString("headLine",
-        l10n_util::GetStringUTF16(
-            IDS_SAFE_BROWSING_PHISHING_QUESTION_HEADLINE));
-  } else if (trialCondition_ == kCond13MalwareGoBack) {
-    strings->SetString("headLine",
-        l10n_util::GetStringUTF16(IDS_SAFE_BROWSING_MALWARE_BACK_HEADLINE));
-  } else if (trialCondition_ == kCond14PhishingGoBack) {
-    strings->SetString("headLine",
-        l10n_util::GetStringUTF16(IDS_SAFE_BROWSING_PHISHING_BACK_HEADLINE));
-  }
-
   webui::SetFontAndTextDirection(strings);
 }
 
 void SafeBrowsingBlockingPageV2::PopulateMultipleThreatStringDictionary(
     base::DictionaryValue* strings) {
   NOTREACHED();
 }
 
 void SafeBrowsingBlockingPageV2::PopulateMalwareStringDictionary(
     base::DictionaryValue* strings) {
@@ skipping 93 matching lines @@
       l10n_util::GetStringUTF16(IDS_SAFE_BROWSING_PHISHING_V2_REPORT_ERROR));
   strings->SetBoolean(kDisplayCheckBox, false);
   strings->SetString("learnMore",
       l10n_util::GetStringUTF16(IDS_SAFE_BROWSING_MALWARE_V2_LEARN_MORE));
 }
 
 SafeBrowsingBlockingPageV3::SafeBrowsingBlockingPageV3(
     SafeBrowsingUIManager* ui_manager,
     WebContents* web_contents,
     const UnsafeResourceList& unsafe_resources)
-    : SafeBrowsingBlockingPage(ui_manager, web_contents, unsafe_resources) {
+    : SafeBrowsingBlockingPage(ui_manager, web_contents, unsafe_resources),
+      trial_condition_(GetTrialCondition()) {
 }
 
 std::string SafeBrowsingBlockingPageV3::GetHTMLContents() {
   if (unsafe_resources_.empty() || unsafe_resources_.size() > 1) {
     // TODO(felt): Implement new multi-threat interstitial. crbug.com/160336
     NOTIMPLEMENTED();
     return std::string();
   }
 
   // Fill in the shared values.
@@ skipping 36 matching lines @@
 
   base::StringPiece html(
       ResourceBundle::GetSharedInstance().GetRawDataResource(
           IRD_SSL_INTERSTITIAL_V2_HTML));
   webui::UseVersion2 version;
   return webui::GetI18nTemplateHtml(html, &load_time_data);
 }
 
 void SafeBrowsingBlockingPageV3::PopulateMalwareLoadTimeData(
     base::DictionaryValue* load_time_data) {
+  load_time_data->SetString("trialCondition", trial_condition_);
   load_time_data->SetBoolean("phishing", false);
   load_time_data->SetString(
       "heading", l10n_util::GetStringUTF16(IDS_MALWARE_V3_HEADING));
   load_time_data->SetString(
       "primaryParagraph",
       l10n_util::GetStringUTF16(IDS_MALWARE_V3_PRIMARY_PARAGRAPH));
-  load_time_data->SetString(
-      "explanationParagraph",
-      is_main_frame_load_blocked_ ?
-          l10n_util::GetStringFUTF16(
-              IDS_MALWARE_V3_EXPLANATION_PARAGRAPH,
-              base::UTF8ToUTF16(url_.host())) :
-          l10n_util::GetStringFUTF16(
-              IDS_MALWARE_V3_EXPLANATION_PARAGRAPH_SUBRESOURCE,
-              base::UTF8ToUTF16(web_contents_->GetURL().host()),
-              base::UTF8ToUTF16(url_.host())));
-  load_time_data->SetString(
-      "finalParagraph",
-      l10n_util::GetStringUTF16(IDS_MALWARE_V3_PROCEED_PARAGRAPH));
+  if (trial_condition_ == kCondV3History) {
+    load_time_data->SetString(
+        "explanationParagraph",
+        is_main_frame_load_blocked_ ?
+            l10n_util::GetStringFUTF16(
+                IDS_MALWARE_V3_EXPLANATION_PARAGRAPH_HISTORY,
+                base::UTF8ToUTF16(url_.host())) :
+            l10n_util::GetStringFUTF16(
+                IDS_MALWARE_V3_EXPLANATION_PARAGRAPH_SUBRESOURCE_HISTORY,
+                base::UTF8ToUTF16(web_contents_->GetURL().host()),
+                base::UTF8ToUTF16(url_.host())));
+  } else if (trial_condition_ == kCondV3Advice) {
+    load_time_data->SetString(
+        "explanationParagraph",
+        is_main_frame_load_blocked_ ?
+            l10n_util::GetStringFUTF16(
+                IDS_MALWARE_V3_EXPLANATION_PARAGRAPH_ADVICE,
+                base::UTF8ToUTF16(url_.host())) :
+            l10n_util::GetStringFUTF16(
+                IDS_MALWARE_V3_EXPLANATION_PARAGRAPH_SUBRESOURCE_ADVICE,
+                base::UTF8ToUTF16(web_contents_->GetURL().host()),
+                base::UTF8ToUTF16(url_.host())));
+    load_time_data->SetString(
+        "adviceHeading",
+        l10n_util::GetStringUTF16(IDS_MALWARE_V3_ADVICE_HEADING));
+  } else {
+    load_time_data->SetString(
+        "explanationParagraph",
+        is_main_frame_load_blocked_ ?
+            l10n_util::GetStringFUTF16(
+                IDS_MALWARE_V3_EXPLANATION_PARAGRAPH,
+                base::UTF8ToUTF16(url_.host())) :
+            l10n_util::GetStringFUTF16(
+                IDS_MALWARE_V3_EXPLANATION_PARAGRAPH_SUBRESOURCE,
+                base::UTF8ToUTF16(web_contents_->GetURL().host()),
+                base::UTF8ToUTF16(url_.host())));
+  }
+  if (trial_condition_ == kCondV3Social) {
+    load_time_data->SetString(
+        "finalParagraph",
+        l10n_util::GetStringUTF16(IDS_MALWARE_V3_PROCEED_PARAGRAPH_SOCIAL));
+  } else if (trial_condition_ == kCondV3NotRecommend) {
+    load_time_data->SetString(
+        "finalParagraph",
+        l10n_util::GetStringUTF16(
+            IDS_MALWARE_V3_PROCEED_PARAGRAPH_NOT_RECOMMEND));
+  } else {
+    load_time_data->SetString(
+        "finalParagraph",
+        l10n_util::GetStringUTF16(IDS_MALWARE_V3_PROCEED_PARAGRAPH));
+  }
 
   load_time_data->SetBoolean(kDisplayCheckBox, CanShowMalwareDetailsOption());
   if (CanShowMalwareDetailsOption()) {
     std::string privacy_link = base::StringPrintf(
         kPrivacyLinkHtml,
         l10n_util::GetStringUTF8(
             IDS_SAFE_BROWSING_PRIVACY_POLICY_PAGE_V2).c_str());
     load_time_data->SetString(
         "optInLink",
         l10n_util::GetStringFUTF16(IDS_SAFE_BROWSING_MALWARE_V2_REPORTING_AGREE,
                                    base::UTF8ToUTF16(privacy_link)));
     Profile* profile = Profile::FromBrowserContext(
        web_contents_->GetBrowserContext());
     if (profile->GetPrefs()->HasPrefPath(
             prefs::kSafeBrowsingExtendedReportingEnabled)) {
       reporting_checkbox_checked_ =
           IsPrefEnabled(prefs::kSafeBrowsingExtendedReportingEnabled);
     } else if (IsPrefEnabled(prefs::kSafeBrowsingReportingEnabled) ||
          IsPrefEnabled(prefs::kSafeBrowsingDownloadFeedbackEnabled)) {
       reporting_checkbox_checked_ = true;
     }
     load_time_data->SetBoolean(
         kBoxChecked, reporting_checkbox_checked_);
   }
 }
 
 void SafeBrowsingBlockingPageV3::PopulatePhishingLoadTimeData(
     base::DictionaryValue* load_time_data) {
+  load_time_data->SetString("trialCondition", std::string());
   load_time_data->SetBoolean("phishing", true);
   load_time_data->SetString(
       "heading",
       l10n_util::GetStringUTF16(IDS_PHISHING_V3_HEADING));
   load_time_data->SetString(
       "primaryParagraph",
       l10n_util::GetStringFUTF16(
           IDS_PHISHING_V3_PRIMARY_PARAGRAPH,
           base::UTF8ToUTF16(url_.host())));
   load_time_data->SetString(
       "explanationParagraph",
       l10n_util::GetStringFUTF16(IDS_PHISHING_V3_EXPLANATION_PARAGRAPH,
                                  base::UTF8ToUTF16(url_.host())));
   load_time_data->SetString(
       "finalParagraph",
       l10n_util::GetStringUTF16(IDS_PHISHING_V3_PROCEED_PARAGRAPH));
 }