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
+                       ? 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) {}

[sgurun-gerrit only, 2017/05/22 21:05:30]

errorType sounds like we are dealing with an error here, while the goal is to
identify the type of UI.  
It is better to rename it to something that is more meaningful - such as
SafeBrowsingInterstitialType or SafeBrowsingInterstitialSize

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

Acknowledged. The member is removed in the latest patchset, and the constructor
parameters have been renamed to errorUiType.

 
 BaseBlockingPage::~BaseBlockingPage() {}
 
 // static
 const security_interstitials::BaseSafeBrowsingErrorUI::SBErrorDisplayOptions
 BaseBlockingPage::CreateDefaultDisplayOptions(
     const UnsafeResourceList& unsafe_resources) {
   return BaseSafeBrowsingErrorUI::SBErrorDisplayOptions(
       IsMainPageLoadBlocked(unsafe_resources),
       false,                 // kSafeBrowsingExtendedReportingOptInAllowed
@@ skipping 20 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