Add UI for the new harmful download warning

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 88 matching lines @@
 const char kShowPrivacyCommand[] = "showPrivacy";
 const char kTakeMeBackCommand[] = "takeMeBack";
 
 // Other constants used to communicate with the JavaScript.
 const char kBoxChecked[] = "boxchecked";
 const char kDisplayCheckBox[] = "displaycheckbox";
 
 // Constants for the Experience Sampling instrumentation.
 #if defined(ENABLE_EXTENSIONS)
 const char kEventNameMalware[] = "safebrowsing_interstitial_";
+const char kEventNameHarmful[] = "harmful_interstitial_";
 const char kEventNamePhishing[] = "phishing_interstitial_";
 const char kEventNameOther[] = "safebrowsing_other_interstitial_";
 #endif
 
 base::LazyInstance<SafeBrowsingBlockingPage::UnsafeResourceMap>
     g_unsafe_resource_map = LAZY_INSTANCE_INITIALIZER;
 
 }  // namespace
 
 // static
@@ skipping 35 matching lines @@
       report_loop_(NULL),
       is_main_frame_load_blocked_(IsMainPageLoadBlocked(unsafe_resources)),
       unsafe_resources_(unsafe_resources),
       proceeded_(false),
       web_contents_(web_contents),
       url_(unsafe_resources[0].url),
       interstitial_page_(NULL),
       create_view_(true),
       num_visits_(-1) {
   bool malware = false;
+  bool harmful = false;
   bool phishing = false;
   for (UnsafeResourceList::const_iterator iter = unsafe_resources_.begin();
        iter != unsafe_resources_.end(); ++iter) {
     const UnsafeResource& resource = *iter;
     SBThreatType threat_type = resource.threat_type;
     if (threat_type == SB_THREAT_TYPE_URL_MALWARE ||
         threat_type == SB_THREAT_TYPE_CLIENT_SIDE_MALWARE_URL) {
       malware = true;
+    } else if (threat_type == SB_THREAT_TYPE_URL_HARMFUL) {
+      harmful = true;
     } else {
       DCHECK(threat_type == SB_THREAT_TYPE_URL_PHISHING ||
              threat_type == SB_THREAT_TYPE_CLIENT_SIDE_PHISHING_URL);
       phishing = true;
     }
   }
-  DCHECK(phishing || malware);
+  DCHECK(phishing || malware || harmful);
   if (malware)
     interstitial_type_ = TYPE_MALWARE;
+  else if (harmful)
+    interstitial_type_ = TYPE_HARMFUL;
   else
     interstitial_type_ = TYPE_PHISHING;
 
   RecordUserDecision(SHOW);
   RecordUserInteraction(TOTAL_VISITS);
   if (IsPrefEnabled(prefs::kSafeBrowsingProceedAnywayDisabled))
     RecordUserDecision(PROCEEDING_DISABLED);
 
   HistoryService* history_service = HistoryServiceFactory::GetForProfile(
           Profile::FromBrowserContext(web_contents->GetBrowserContext()),
@@ skipping 26 matching lines @@
   }
 
 #if defined(ENABLE_EXTENSIONS)
   // ExperienceSampling: Set up new sampling event for this interstitial.
   // This needs to handle all types of warnings this interstitial can show.
   std::string event_name;
   switch (interstitial_type_) {
     case TYPE_MALWARE:
       event_name = kEventNameMalware;
       break;
+    case TYPE_HARMFUL:
+      event_name = kEventNameHarmful;
+      break;
     case TYPE_PHISHING:
       event_name = kEventNamePhishing;
       break;
     default:
       event_name = kEventNameOther;
       break;
   }
   sampling_event_.reset(new ExperienceSamplingEvent(
       event_name,
       url_,
@@ skipping 248 matching lines @@
     num_visits_ = num_visits;
 }
 
 void SafeBrowsingBlockingPage::RecordUserDecision(Decision decision) {
   switch (interstitial_type_) {
     case TYPE_MALWARE:
       UMA_HISTOGRAM_ENUMERATION("interstitial.malware.decision",
                                 decision,
                                 MAX_DECISION);
       break;
+    case TYPE_HARMFUL:
+      UMA_HISTOGRAM_ENUMERATION("interstitial.harmful.decision",
+                                decision,
+                                MAX_DECISION);
+      break;
     case TYPE_PHISHING:
       UMA_HISTOGRAM_ENUMERATION("interstitial.phishing.decision",
                                 decision,
                                 MAX_DECISION);
       break;
-    default:
-      NOTREACHED();
   }
 
 #if defined(ENABLE_EXTENSIONS)
   if (sampling_event_.get()) {
     switch (decision) {
       case PROCEED:
         sampling_event_->CreateUserDecisionEvent(
             ExperienceSamplingEvent::kProceed);
         break;
       case DONT_PROCEED:
@@ skipping 22 matching lines @@
   }
 }
 
 void SafeBrowsingBlockingPage::RecordUserInteraction(Interaction interaction) {
   switch (interstitial_type_) {
     case TYPE_MALWARE:
       UMA_HISTOGRAM_ENUMERATION("interstitial.malware.interaction",
                                 interaction,
                                 MAX_INTERACTION);
       break;
+    case TYPE_HARMFUL:
+      UMA_HISTOGRAM_ENUMERATION("interstitial.harmful.interaction",
+                                interaction,
+                                MAX_INTERACTION);
+      break;
     case TYPE_PHISHING:
       UMA_HISTOGRAM_ENUMERATION("interstitial.phishing.interaction",
                                 interaction,
                                 MAX_INTERACTION);
       break;
     default:
       NOTREACHED();

[mattm, 2014/09/19 21:28:16]

remove this default case too?

[felt, 2014/09/22 16:42:16]

Done.

   }
 
 #if defined(ENABLE_EXTENSIONS)
   if (!sampling_event_.get())
     return;
   switch (interaction) {
     case SHOW_LEARN_MORE:
       sampling_event_->set_has_viewed_learn_more(true);
       break;
     case SHOW_ADVANCED:
@@ skipping 122 matching lines @@
   load_time_data.SetString(
       "closeDetails",
       l10n_util::GetStringUTF16(IDS_SAFEBROWSING_V3_CLOSE_DETAILS_BUTTON));
   load_time_data.SetString(
       "primaryButtonText",
       l10n_util::GetStringUTF16(IDS_SAFEBROWSING_OVERRIDABLE_SAFETY_BUTTON));
   load_time_data.SetBoolean(
       "overridable",
       !IsPrefEnabled(prefs::kSafeBrowsingProceedAnywayDisabled));
 
-  if (interstitial_type_ == TYPE_PHISHING)
-    PopulatePhishingLoadTimeData(&load_time_data);
-  else
-    PopulateMalwareLoadTimeData(&load_time_data);
+  switch (interstitial_type_) {
+    case TYPE_MALWARE:
+      PopulateMalwareLoadTimeData(&load_time_data);
+      break;
+    case TYPE_HARMFUL:
+      PopulateHarmfulLoadTimeData(&load_time_data);
+      break;
+    case TYPE_PHISHING:
+      PopulatePhishingLoadTimeData(&load_time_data);
+      break;
+  }
 
   base::StringPiece html(
       ResourceBundle::GetSharedInstance().GetRawDataResource(
           IRD_SECURITY_INTERSTITIAL_HTML));
   webui::UseVersion2 version;
   return webui::GetI18nTemplateHtml(html, &load_time_data);
 }
 
 void SafeBrowsingBlockingPage::PopulateMalwareLoadTimeData(
     base::DictionaryValue* load_time_data) {
@@ skipping 28 matching lines @@
     load_time_data->SetString(
         "optInLink",
         l10n_util::GetStringFUTF16(IDS_SAFE_BROWSING_MALWARE_REPORTING_AGREE,
                                    base::UTF8ToUTF16(privacy_link)));
     load_time_data->SetBoolean(
         kBoxChecked,
         IsPrefEnabled(prefs::kSafeBrowsingExtendedReportingEnabled));
   }
 }
 
+void SafeBrowsingBlockingPage::PopulateHarmfulLoadTimeData(
+    base::DictionaryValue* load_time_data) {
+  load_time_data->SetBoolean("phishing", false);
+  load_time_data->SetString(
+      "heading", l10n_util::GetStringUTF16(IDS_HARMFUL_V3_HEADING));
+  load_time_data->SetString(
+      "primaryParagraph",
+      l10n_util::GetStringFUTF16(
+          IDS_HARMFUL_V3_PRIMARY_PARAGRAPH,
+          base::UTF8ToUTF16(url_.host())));
+  load_time_data->SetString(
+      "explanationParagraph",
+      l10n_util::GetStringFUTF16(
+          IDS_HARMFUL_V3_EXPLANATION_PARAGRAPH,
+          base::UTF8ToUTF16(url_.host())));
+  load_time_data->SetString(
+      "finalParagraph",
+      l10n_util::GetStringUTF16(IDS_HARMFUL_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).c_str());
+    load_time_data->SetString(
+        "optInLink",
+        l10n_util::GetStringFUTF16(IDS_SAFE_BROWSING_MALWARE_REPORTING_AGREE,
+                                   base::UTF8ToUTF16(privacy_link)));
+    load_time_data->SetBoolean(
+        kBoxChecked,
+        IsPrefEnabled(prefs::kSafeBrowsingExtendedReportingEnabled));
+  }
+}
+
 void SafeBrowsingBlockingPage::PopulatePhishingLoadTimeData(
     base::DictionaryValue* load_time_data) {
   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));
 }