WebView: choose loud vs. quiet interstitial

components/safe_browsing/base_blocking_page.cc

 // Copyright 2017 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 "components/safe_browsing/base_blocking_page.h"
 
 #include "base/bind.h"
 #include "base/lazy_instance.h"
 #include "base/memory/ptr_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/time/time.h"
+#include "components/grit/components_resources.h"
 #include "components/safe_browsing/common/safe_browsing_prefs.h"
 #include "components/security_interstitials/content/security_interstitial_controller_client.h"
 #include "components/security_interstitials/core/metrics_helper.h"
 #include "components/security_interstitials/core/safe_browsing_loud_error_ui.h"
+#include "components/security_interstitials/core/safe_browsing_quiet_error_ui.h"
 #include "content/public/browser/interstitial_page.h"
 #include "content/public/browser/navigation_entry.h"
 #include "content/public/browser/web_contents.h"
 
 using content::InterstitialPage;
 using content::WebContents;
 using security_interstitials::BaseSafeBrowsingErrorUI;
 using security_interstitials::SafeBrowsingLoudErrorUI;
+using security_interstitials::SafeBrowsingQuietErrorUI;
 using security_interstitials::SecurityInterstitialControllerClient;
 
 namespace safe_browsing {
 
 namespace {
 
 // After a safe browsing interstitial where the user opted-in to the report
 // but clicked "proceed anyway", we delay the call to
 // ThreatDetails::FinishCollection() by this much time (in
 // milliseconds).
 const int64_t kThreatDetailsProceedDelayMilliSeconds = 3000;
 
 base::LazyInstance<BaseBlockingPage::UnsafeResourceMap>::Leaky
     g_unsafe_resource_map = LAZY_INSTANCE_INITIALIZER;
 
 }  // namespace
 
 BaseBlockingPage::BaseBlockingPage(
     BaseUIManager* ui_manager,
     WebContents* web_contents,
     const GURL& main_frame_url,
     const UnsafeResourceList& unsafe_resources,
     std::unique_ptr<SecurityInterstitialControllerClient> controller_client,
-    const BaseSafeBrowsingErrorUI::SBErrorDisplayOptions& display_options)
+    const BaseSafeBrowsingErrorUI::SBErrorDisplayOptions& display_options,
+    ErrorUiType error_type)
     : SecurityInterstitialPage(web_contents,
                                unsafe_resources[0].url,
                                std::move(controller_client)),
       ui_manager_(ui_manager),
       main_frame_url_(main_frame_url),
       navigation_entry_index_to_remove_(
           IsMainPageLoadBlocked(unsafe_resources)
               ? -1
               : web_contents->GetController().GetLastCommittedEntryIndex()),
       unsafe_resources_(unsafe_resources),
-      sb_error_ui_(base::MakeUnique<SafeBrowsingLoudErrorUI>(
-          unsafe_resources_[0].url,
-          main_frame_url_,
-          GetInterstitialReason(unsafe_resources_),
-          display_options,
-          ui_manager->app_locale(),
-          base::Time::NowFromSystemTime(),
-          controller())),
+      sb_error_ui_(error_type == ErrorUiType::LOUD

[Jialiu Lin, 2017/05/22 17:06:00]

nit: construction list is supposed to be simple. How about moving the creation
of sb_error_ui_ into the body of constructor?

[Nate Fischer, 2017/05/22 23:13:46]

Done.

+                       ? static_cast<std::unique_ptr<BaseSafeBrowsingErrorUI>>(
+                             base::MakeUnique<SafeBrowsingLoudErrorUI>(
+                                 unsafe_resources_[0].url,
+                                 main_frame_url_,
+                                 GetInterstitialReason(unsafe_resources_),
+                                 display_options,
+                                 ui_manager->app_locale(),
+                                 base::Time::NowFromSystemTime(),
+                                 controller()))
+                       : static_cast<std::unique_ptr<BaseSafeBrowsingErrorUI>>(
+                             base::MakeUnique<SafeBrowsingQuietErrorUI>(
+                                 unsafe_resources_[0].url,
+                                 main_frame_url_,
+                                 GetInterstitialReason(unsafe_resources_),
+                                 display_options,
+                                 ui_manager->app_locale(),
+                                 base::Time::NowFromSystemTime(),
+                                 controller(),
+                                 error_type == ErrorUiType::QUIET_GIANT))),
       proceeded_(false),
-      threat_details_proceed_delay_ms_(kThreatDetailsProceedDelayMilliSeconds) {
-}
+      threat_details_proceed_delay_ms_(kThreatDetailsProceedDelayMilliSeconds),
+      error_type_(error_type) {}
 
 BaseBlockingPage::~BaseBlockingPage() {}
 
 // static
 const security_interstitials::BaseSafeBrowsingErrorUI::SBErrorDisplayOptions
 BaseBlockingPage::CreateDefaultDisplayOptions(
     const UnsafeResourceList& unsafe_resources) {
   return BaseSafeBrowsingErrorUI::SBErrorDisplayOptions(
       IsMainPageLoadBlocked(unsafe_resources),
       false,  // kSafeBrowsingExtendedReportingOptInAllowed
@@ skipping 19 matching lines @@
     // There is no interstitial currently showing in that tab, or we are about
     // to display a new one for the main frame. If there is already an
     // interstitial, showing the new one will automatically hide the old one.
     content::NavigationEntry* entry =
         unsafe_resource.GetNavigationEntryForResource();
     const UnsafeResourceList unsafe_resources{unsafe_resource};
     BaseBlockingPage* blocking_page = new BaseBlockingPage(
         ui_manager, web_contents, entry ? entry->GetURL() : GURL(),
         unsafe_resources,
         CreateControllerClient(web_contents, unsafe_resources, ui_manager),
-        CreateDefaultDisplayOptions(unsafe_resources));
+        CreateDefaultDisplayOptions(unsafe_resources), ErrorUiType::LOUD);
     blocking_page->Show();
   }
 }
 
 // static
 bool BaseBlockingPage::IsMainPageLoadBlocked(
     const UnsafeResourceList& unsafe_resources) {
   // If there is more than one unsafe resource, the main page load must not be
   // blocked. Otherwise, check if the one resource is.
   return unsafe_resources.size() == 1 &&
@@ skipping 224 matching lines @@
   std::unique_ptr<security_interstitials::MetricsHelper> metrics_helper =
       base::MakeUnique<security_interstitials::MetricsHelper>(
           unsafe_resources[0].url, GetReportingInfo(unsafe_resources),
           history_service);
 
   return base::MakeUnique<SecurityInterstitialControllerClient>(
       web_contents, std::move(metrics_helper), nullptr, /* prefs */
       ui_manager->app_locale(), ui_manager->default_safe_page());
 }
 
+int BaseBlockingPage::GetHTMLTemplateId() {
+  return error_type_ == ErrorUiType::LOUD
+             ? IDR_SECURITY_INTERSTITIAL_HTML
+             : IDR_SECURITY_INTERSTITIAL_QUIET_HTML;
+}
+
 }  // namespace safe_browsing