Refactor BaseBlockingPage to reduce duplicated code

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/safe_browsing_db/safe_browsing_prefs.h"
 #include "components/security_interstitials/content/security_interstitial_controller_client.h"
 #include "components/security_interstitials/core/metrics_helper.h"
 #include "content/public/browser/interstitial_page.h"
 #include "content/public/browser/navigation_entry.h"
 #include "content/public/browser/user_metrics.h"
 #include "content/public/browser/web_contents.h"
 
 using base::UserMetricsAction;
 using content::InterstitialPage;
 using content::WebContents;
 using security_interstitials::SafeBrowsingErrorUI;
 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 SafeBrowsingErrorUI::SBErrorDisplayOptions& display_options)
     : 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()),
+          IsMainPageLoadBlocked(unsafe_resources)
+              ? -1
+              : web_contents->GetController().GetLastCommittedEntryIndex()),
       unsafe_resources_(unsafe_resources),
       sb_error_ui_(base::MakeUnique<SafeBrowsingErrorUI>(
-                       unsafe_resources_[0].url, main_frame_url_,
-                       GetInterstitialReason(unsafe_resources_),
-                       display_options,
-                       ui_manager->app_locale(),
-                       base::Time::NowFromSystemTime(),
-                       controller())),
-      proceeded_(false) {}
+          unsafe_resources_[0].url,
+          main_frame_url_,
+          GetInterstitialReason(unsafe_resources_),
+          display_options,
+          ui_manager->app_locale(),
+          base::Time::NowFromSystemTime(),
+          controller())),
+      proceeded_(false),
+      threat_details_proceed_delay_ms_(kThreatDetailsProceedDelayMilliSeconds) {
+}
 
 BaseBlockingPage::~BaseBlockingPage() {}
 
 // static
 const SafeBrowsingErrorUI::SBErrorDisplayOptions
 BaseBlockingPage::CreateDefaultDisplayOptions() {
   return SafeBrowsingErrorUI::SBErrorDisplayOptions(
       true,    // IsMainPageLoadBlocked()
       false,   // kSafeBrowsingExtendedReportingOptInAllowed
       false,   // is_off_the_record
       false,   // is_extended_reporting
       false,   // is_scout
       false);  // kSafeBrowsingProceedAnywayDisabled
 }
 
 // static
 void BaseBlockingPage::ShowBlockingPage(
     BaseUIManager* ui_manager,
     const UnsafeResource& unsafe_resource) {
   WebContents* web_contents = unsafe_resource.web_contents_getter.Run();
 
-  if (!InterstitialPage::GetInterstitialPage(web_contents) ||
-      !unsafe_resource.is_subresource) {
+  if (InterstitialPage::GetInterstitialPage(web_contents) &&
+      unsafe_resource.is_subresource) {
+    // This is an interstitial for a page's resource, let's queue it.
+    UnsafeResourceMap* unsafe_resource_map = GetUnsafeResourcesMap();
+    (*unsafe_resource_map)[web_contents].push_back(unsafe_resource);
+  } else {
     // 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 resources{unsafe_resource};
-    BaseBlockingPage* blocking_page =
-        new BaseBlockingPage(
-            ui_manager, web_contents,
-            entry ? entry->GetURL() : GURL(),
-            resources,
-            CreateControllerClient(
-                web_contents, resources,
-                ui_manager->history_service(web_contents),
-                ui_manager->app_locale(),
-                ui_manager->default_safe_page()),
-                CreateDefaultDisplayOptions());
+    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());
     blocking_page->Show();
-    return;
   }
-
-  // This is an interstitial for a page's resource, let's queue it.
-  UnsafeResourceMap* unsafe_resource_map = GetUnsafeResourcesMap();
-  (*unsafe_resource_map)[web_contents].push_back(unsafe_resource);
 }
 
 // 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 &&
          unsafe_resources[0].IsMainPageLoadBlocked();
 }
 
 void BaseBlockingPage::OnProceed() {
-  proceeded_ = true;
+  set_proceeded(true);
+  UpdateMetricsAfterSecurityInterstitial();
+
+  // Send the threat details, if we opted to.
+  FinishThreatDetails(
+      base::TimeDelta::FromMilliseconds(threat_details_proceed_delay_ms_),
+      true, /* did_proceed */
+      controller()->metrics_helper()->NumVisits());
 
   ui_manager_->OnBlockingPageDone(unsafe_resources_, true /* proceed */,
                                   web_contents(), main_frame_url_);
+
+  HandleSubresourcesAfterProceed();
+}
+
+void BaseBlockingPage::HandleSubresourcesAfterProceed() {}
+
+void BaseBlockingPage::SetThreatDetailsProceedDelayForTesting(int64_t delay) {
+  threat_details_proceed_delay_ms_ = delay;
 }
 
 void BaseBlockingPage::OnDontProceed() {
   // We could have already called Proceed(), in which case we must not notify
   // the SafeBrowsingUIManager again, as the client has been deleted.
   if (proceeded_)
     return;
 
   UpdateMetricsAfterSecurityInterstitial();
   if (!sb_error_ui_->is_proceed_anyway_disabled()) {
@@ skipping 160 matching lines @@
 
 SafeBrowsingErrorUI* BaseBlockingPage::sb_error_ui() const {
   return sb_error_ui_.get();
 }
 
 void BaseBlockingPage::set_proceeded(bool proceeded) {
   proceeded_ = proceeded;
 }
 
 // static
+security_interstitials::MetricsHelper::ReportDetails
+BaseBlockingPage::GetReportingInfo(const UnsafeResourceList& unsafe_resources) {
+  SafeBrowsingErrorUI::SBInterstitialReason interstitial_reason =
+      GetInterstitialReason(unsafe_resources);
+
+  security_interstitials::MetricsHelper::ReportDetails reporting_info;
+  reporting_info.metric_prefix =
+      GetMetricPrefix(unsafe_resources, interstitial_reason);
+  reporting_info.extra_suffix = GetExtraMetricsSuffix(unsafe_resources);
+  return reporting_info;
+}
+
+// static
 std::unique_ptr<SecurityInterstitialControllerClient>
 BaseBlockingPage::CreateControllerClient(
     content::WebContents* web_contents,
     const UnsafeResourceList& unsafe_resources,
-    history::HistoryService* history_service,
-    const std::string& app_locale,
-    const GURL& default_safe_page) {
-  SafeBrowsingErrorUI::SBInterstitialReason interstitial_reason =
-      GetInterstitialReason(unsafe_resources);
-  security_interstitials::MetricsHelper::ReportDetails reporting_info;
-  reporting_info.metric_prefix =
-      GetMetricPrefix(unsafe_resources, interstitial_reason);
-  reporting_info.extra_suffix = GetExtraMetricsSuffix(unsafe_resources);
+    BaseUIManager* ui_manager) {
+  history::HistoryService* history_service =
+      ui_manager->history_service(web_contents);
 
   std::unique_ptr<security_interstitials::MetricsHelper> metrics_helper =
       base::MakeUnique<security_interstitials::MetricsHelper>(
-          unsafe_resources[0].url, reporting_info, history_service);
+          unsafe_resources[0].url, GetReportingInfo(unsafe_resources),
+          history_service);
 
   return base::MakeUnique<SecurityInterstitialControllerClient>(
-      web_contents, std::move(metrics_helper), nullptr, app_locale,
-      default_safe_page);
+      web_contents, std::move(metrics_helper), nullptr, /* prefs */
+      ui_manager->app_locale(), ui_manager->default_safe_page());
 }
 
 }  // namespace safe_browsing