Remove redundancy in security interstitial UMA logic

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>
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/i18n/rtl.h"
 #include "base/lazy_instance.h"
 #include "base/metrics/field_trial.h"
 #include "base/metrics/histogram.h"
 #include "base/prefs/pref_service.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_piece.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/time/time.h"
 #include "base/values.h"
 #include "chrome/browser/browser_process.h"
-#include "chrome/browser/history/history_service_factory.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/renderer_preferences_util.h"
 #include "chrome/browser/safe_browsing/malware_details.h"
 #include "chrome/browser/safe_browsing/ui_manager.h"
 #include "chrome/browser/tab_contents/tab_util.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/common/url_constants.h"
 #include "chrome/grit/generated_resources.h"
 #include "chrome/grit/locale_settings.h"
 #include "components/google/core/browser/google_util.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/interstitial_page.h"
 #include "content/public/browser/navigation_controller.h"
 #include "content/public/browser/user_metrics.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/common/renderer_preferences.h"
 #include "grit/browser_resources.h"
 #include "net/base/escape.h"
 #include "ui/base/l10n/l10n_util.h"
 
-#if defined(ENABLE_EXTENSIONS)
-#include "chrome/browser/extensions/api/experience_sampling_private/experience_sampling.h"
-#endif
-
 using base::UserMetricsAction;
 using content::BrowserThread;
 using content::InterstitialPage;
 using content::OpenURLParams;
 using content::Referrer;
 using content::WebContents;
 
-#if defined(ENABLE_EXTENSIONS)
-using extensions::ExperienceSamplingEvent;
-#endif
-
 namespace {
 
 // For malware interstitial pages, we link the problematic URL to Google's
 // diagnostic page.
 #if defined(GOOGLE_CHROME_BUILD)
 const char kSbDiagnosticUrl[] =
     "http://safebrowsing.clients.google.com/safebrowsing/diagnostic?site=%s&client=googlechrome";
 #else
 const char kSbDiagnosticUrl[] =
     "http://safebrowsing.clients.google.com/safebrowsing/diagnostic?site=%s&client=chromium";
@@ skipping 23 matching lines @@
 const char kProceedCommand[] = "proceed";
 const char kShowDiagnosticCommand[] = "showDiagnostic";
 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
 SafeBrowsingBlockingPageFactory* SafeBrowsingBlockingPage::factory_ = NULL;
 
 // The default SafeBrowsingBlockingPageFactory.  Global, made a singleton so we
@@ skipping 30 matching lines @@
     SafeBrowsingUIManager* ui_manager,
     WebContents* web_contents,
     const UnsafeResourceList& unsafe_resources)
     : SecurityInterstitialPage(web_contents, unsafe_resources[0].url),
       malware_details_proceed_delay_ms_(
           kMalwareDetailsProceedDelayMilliSeconds),
       ui_manager_(ui_manager),
       report_loop_(NULL),
       is_main_frame_load_blocked_(IsMainPageLoadBlocked(unsafe_resources)),
       unsafe_resources_(unsafe_resources),
-      proceeded_(false),
-      num_visits_(-1) {
+      proceeded_(false) {
   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_UNWANTED) {
       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 || harmful);
   if (malware)
-    interstitial_type_ = TYPE_MALWARE;
+    interstitial_reason_ = SB_REASON_MALWARE;
   else if (harmful)
-    interstitial_type_ = TYPE_HARMFUL;
+    interstitial_reason_ = SB_REASON_HARMFUL;
   else
-    interstitial_type_ = TYPE_PHISHING;
+    interstitial_reason_ = SB_REASON_PHISHING;
 
-  RecordUserDecision(SHOW);
-  RecordUserInteraction(TOTAL_VISITS);
-  if (IsPrefEnabled(prefs::kSafeBrowsingProceedAnywayDisabled))
-    RecordUserDecision(PROCEEDING_DISABLED);
-
-  HistoryService* history_service = HistoryServiceFactory::GetForProfile(
-      Profile::FromBrowserContext(web_contents->GetBrowserContext()),
-      ServiceAccessType::EXPLICIT_ACCESS);
-  if (history_service) {
-    history_service->GetVisibleVisitCountToHost(
-        request_url(),
-        base::Bind(&SafeBrowsingBlockingPage::OnGotHistoryCount,
-                   base::Unretained(this)),
-        &request_tracker_);
+  uma_helper_.reset(new SecurityInterstitialUmaHelper(
+      web_contents, request_url(),
+      GetHistogramPrefix(), GetSamplingEventName()));
+  uma_helper_->RecordUserDecision(SecurityInterstitialUmaHelper::SHOW);
+  uma_helper_->RecordUserInteraction(
+      SecurityInterstitialUmaHelper::TOTAL_VISITS);
+  if (IsPrefEnabled(prefs::kSafeBrowsingProceedAnywayDisabled)) {
+    uma_helper_->RecordUserDecision(
+        SecurityInterstitialUmaHelper::PROCEEDING_DISABLED);
   }
 
   if (!is_main_frame_load_blocked_) {
     navigation_entry_index_to_remove_ =
         web_contents->GetController().GetLastCommittedEntryIndex();
   } else {
     navigation_entry_index_to_remove_ = -1;
   }
 
   // Start computing malware details. They will be sent only
   // if the user opts-in on the blocking page later.
   // If there's more than one malicious resources, it means the user
   // clicked through the first warning, so we don't prepare additional
   // reports.
   if (unsafe_resources.size() == 1 &&
       unsafe_resources[0].threat_type == SB_THREAT_TYPE_URL_MALWARE &&
       malware_details_.get() == NULL && CanShowMalwareDetailsOption()) {
     malware_details_ = MalwareDetails::NewMalwareDetails(
         ui_manager_, web_contents, unsafe_resources[0]);
   }
-
-#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,
-      request_url(),
-      web_contents->GetLastCommittedURL(),
-      web_contents->GetBrowserContext()));
-#endif
 }
 
 bool SafeBrowsingBlockingPage::CanShowMalwareDetailsOption() {
   return (!web_contents()->GetBrowserContext()->IsOffTheRecord() &&
           web_contents()->GetURL().SchemeIs(url::kHttpScheme));
 }
 
 SafeBrowsingBlockingPage::~SafeBrowsingBlockingPage() {
 }
 
 void SafeBrowsingBlockingPage::CommandReceived(const std::string& cmd) {
   std::string command(cmd);  // Make a local copy so we can modify it.
   // The Jasonified response has quotes, remove them.
   if (command.length() > 1 && command[0] == '"') {
     command = command.substr(1, command.length() - 2);
   }
   if (command == kDoReportCommand) {
     SetReportingPreference(true);
     return;
   }
 
   if (command == kDontReportCommand) {
     SetReportingPreference(false);
     return;
   }
 
   if (command == kLearnMoreCommand) {
     // User pressed "Learn more".
-    RecordUserInteraction(SHOW_LEARN_MORE);
-    GURL learn_more_url(interstitial_type_ == TYPE_PHISHING ?
-                        kLearnMorePhishingUrlV2 : kLearnMoreMalwareUrlV2);
+    uma_helper_->RecordUserInteraction(
+        SecurityInterstitialUmaHelper::SHOW_LEARN_MORE);
+    GURL learn_more_url(
+        interstitial_reason_ == SB_REASON_PHISHING ?
+        kLearnMorePhishingUrlV2 : kLearnMoreMalwareUrlV2);
     learn_more_url = google_util::AppendGoogleLocaleParam(
         learn_more_url, g_browser_process->GetApplicationLocale());
     OpenURLParams params(learn_more_url,
                          Referrer(),
                          CURRENT_TAB,
                          ui::PAGE_TRANSITION_LINK,
                          false);
     web_contents()->OpenURL(params);
     return;
   }
 
   if (command == kShowPrivacyCommand) {
     // User pressed "Safe Browsing privacy policy".
-    RecordUserInteraction(SHOW_PRIVACY_POLICY);
+    uma_helper_->RecordUserInteraction(
+        SecurityInterstitialUmaHelper::SHOW_PRIVACY_POLICY);
     GURL privacy_url(
         l10n_util::GetStringUTF8(IDS_SAFE_BROWSING_PRIVACY_POLICY_URL));
     privacy_url = google_util::AppendGoogleLocaleParam(
         privacy_url, g_browser_process->GetApplicationLocale());
     OpenURLParams params(privacy_url,
                          Referrer(),
                          CURRENT_TAB,
                          ui::PAGE_TRANSITION_LINK,
                          false);
     web_contents()->OpenURL(params);
     return;
   }
 
   bool proceed_blocked = false;
   if (command == kProceedCommand) {
     if (IsPrefEnabled(prefs::kSafeBrowsingProceedAnywayDisabled)) {
       proceed_blocked = true;
     } else {
-      RecordUserDecision(PROCEED);
+      uma_helper_->RecordUserDecision(SecurityInterstitialUmaHelper::PROCEED);
       interstitial_page()->Proceed();
       // |this| has been deleted after Proceed() returns.
       return;
     }
   }
 
   if (command == kTakeMeBackCommand || proceed_blocked) {
     // Don't record the user action here because there are other ways of
     // triggering DontProceed, like clicking the back button.
     if (is_main_frame_load_blocked_) {
@@ skipping 35 matching lines @@
   }
 
   if (element_index >= unsafe_resources_.size()) {
     NOTREACHED();
     return;
   }
 
   std::string bad_url_spec = unsafe_resources_[element_index].url.spec();
   if (command == kShowDiagnosticCommand) {
     // We're going to take the user to Google's SafeBrowsing diagnostic page.
-    RecordUserInteraction(SHOW_DIAGNOSTIC);
+    uma_helper_->RecordUserInteraction(
+        SecurityInterstitialUmaHelper::SHOW_DIAGNOSTIC);
     std::string diagnostic =
         base::StringPrintf(kSbDiagnosticUrl,
             net::EscapeQueryParamValue(bad_url_spec, true).c_str());
     GURL diagnostic_url(diagnostic);
     diagnostic_url = google_util::AppendGoogleLocaleParam(
         diagnostic_url, g_browser_process->GetApplicationLocale());
     DCHECK(unsafe_resources_[element_index].threat_type ==
                SB_THREAT_TYPE_URL_MALWARE ||
            unsafe_resources_[element_index].threat_type ==
                SB_THREAT_TYPE_CLIENT_SIDE_MALWARE_URL ||
            unsafe_resources_[element_index].threat_type ==
                SB_THREAT_TYPE_URL_UNWANTED);
     OpenURLParams params(
         diagnostic_url, Referrer(), CURRENT_TAB, ui::PAGE_TRANSITION_LINK,
         false);
     web_contents()->OpenURL(params);
     return;
   }
 
   if (command == kExpandedSeeMoreCommand) {
-    RecordUserInteraction(SHOW_ADVANCED);
+    uma_helper_->RecordUserInteraction(
+        SecurityInterstitialUmaHelper::SHOW_ADVANCED);
     return;
   }
 
   NOTREACHED() << "Unexpected command: " << command;
 }
 
 void SafeBrowsingBlockingPage::OverrideRendererPrefs(
       content::RendererPreferences* prefs) {
   Profile* profile = Profile::FromBrowserContext(
       web_contents()->GetBrowserContext());
@@ skipping 43 matching lines @@
 bool SafeBrowsingBlockingPage::ShouldCreateNewNavigation() const {
   return is_main_frame_load_blocked_;
 }
 
 void SafeBrowsingBlockingPage::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;
 
-  if (!IsPrefEnabled(prefs::kSafeBrowsingProceedAnywayDisabled))
-    RecordUserDecision(DONT_PROCEED);
+  if (!IsPrefEnabled(prefs::kSafeBrowsingProceedAnywayDisabled)) {
+    uma_helper_->RecordUserDecision(
+        SecurityInterstitialUmaHelper::DONT_PROCEED);
+  }
 
   // Send the malware details, if we opted to.
   FinishMalwareDetails(0);  // No delay
 
   NotifySafeBrowsingUIManager(ui_manager_, unsafe_resources_, false);
 
   // The user does not want to proceed, clear the queued unsafe resources
   // notifications we received while the interstitial was showing.
   UnsafeResourceMap* unsafe_resource_map = GetUnsafeResourcesMap();
   UnsafeResourceMap::iterator iter = unsafe_resource_map->find(web_contents());
@@ skipping 11 matching lines @@
       web_contents()->GetController().GetLastCommittedEntryIndex();
   if (navigation_entry_index_to_remove_ != -1 &&
       navigation_entry_index_to_remove_ != last_committed_index &&
       !web_contents()->IsBeingDestroyed()) {
     CHECK(web_contents()->GetController().RemoveEntryAtIndex(
         navigation_entry_index_to_remove_));
     navigation_entry_index_to_remove_ = -1;
   }
 }
 
-void SafeBrowsingBlockingPage::OnGotHistoryCount(bool success,
-                                                 int num_visits,
-                                                 base::Time first_visit) {
-  if (success)
-    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;
-  }
-
-#if defined(ENABLE_EXTENSIONS)
-  if (sampling_event_.get()) {
-    switch (decision) {
-      case PROCEED:
-        sampling_event_->CreateUserDecisionEvent(
-            ExperienceSamplingEvent::kProceed);
-        break;
-      case DONT_PROCEED:
-        sampling_event_->CreateUserDecisionEvent(
-            ExperienceSamplingEvent::kDeny);
-        break;
-      case SHOW:
-      case PROCEEDING_DISABLED:
-      case MAX_DECISION:
-        break;
-    }
-  }
-#endif
-
-  // Record additional information about malware sites that users have
-  // visited before.
-  if (num_visits_ < 1 || interstitial_type_ != TYPE_MALWARE)
-    return;
-  if (decision == PROCEED || decision == DONT_PROCEED) {
-    UMA_HISTOGRAM_ENUMERATION("interstitial.malware.decision.repeat_visit",
-                              SHOW,
-                              MAX_DECISION);
-    UMA_HISTOGRAM_ENUMERATION("interstitial.malware.decision.repeat_visit",
-                              decision,
-                              MAX_DECISION);
-  }
-}
-
-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;
-  }
-
-#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:
-      sampling_event_->set_has_viewed_details(true);
-      break;
-    case SHOW_PRIVACY_POLICY:
-    case SHOW_DIAGNOSTIC:
-    case TOTAL_VISITS:
-    case MAX_INTERACTION:
-      break;
-  }
-#endif
-}
-
 void SafeBrowsingBlockingPage::FinishMalwareDetails(int64 delay_ms) {
   if (malware_details_.get() == NULL)
     return;  // Not all interstitials have malware details (eg phishing).
-  DCHECK(interstitial_type_ == TYPE_MALWARE);
+  DCHECK(interstitial_reason_ == SB_REASON_MALWARE);
 
   const bool enabled =
       IsPrefEnabled(prefs::kSafeBrowsingExtendedReportingEnabled);
   UMA_HISTOGRAM_BOOLEAN("SB2.ExtendedReportingIsEnabled", enabled);
   if (enabled) {
     // Finish the malware details collection, send it over.
     BrowserThread::PostDelayedTask(
         BrowserThread::IO, FROM_HERE,
         base::Bind(&MalwareDetails::FinishCollection, malware_details_.get()),
         base::TimeDelta::FromMilliseconds(delay_ms));
@@ skipping 76 matching lines @@
   // load, since they happen after the page is finished loading.
   if (unsafe_resources[0].threat_type ==
       SB_THREAT_TYPE_CLIENT_SIDE_PHISHING_URL) {
     return false;
   }
 
   // Otherwise, check the threat type.
   return unsafe_resources.size() == 1 && !unsafe_resources[0].is_subresource;
 }
 
+std::string SafeBrowsingBlockingPage::GetHistogramPrefix() const {
+  switch (interstitial_reason_) {
+    case SB_REASON_MALWARE:
+      return "malware";
+    case SB_REASON_HARMFUL:
+      return "harmful";
+    case SB_REASON_PHISHING:
+      return "phishing";
+  }
+  NOTREACHED();
+}
+
+std::string SafeBrowsingBlockingPage::GetSamplingEventName() const {
+  switch (interstitial_reason_) {
+    case SB_REASON_MALWARE:
+      return kEventNameMalware;
+    case SB_REASON_HARMFUL:
+      return kEventNameHarmful;
+    case SB_REASON_PHISHING:
+      return kEventNamePhishing;
+    default:
+      return kEventNameOther;
+  }
+  NOTREACHED();
+}
+
 void SafeBrowsingBlockingPage::PopulateInterstitialStrings(
     base::DictionaryValue* load_time_data) {
   CHECK(load_time_data);
   CHECK(!unsafe_resources_.empty());
 
   load_time_data->SetString("type", "SAFEBROWSING");
   load_time_data->SetString(
       "tabTitle", l10n_util::GetStringUTF16(IDS_SAFEBROWSING_V3_TITLE));
   load_time_data->SetString(
       "openDetails",
       l10n_util::GetStringUTF16(IDS_SAFEBROWSING_V3_OPEN_DETAILS_BUTTON));
   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));
 
-  switch (interstitial_type_) {
-    case TYPE_MALWARE:
+  switch (interstitial_reason_) {
+    case SB_REASON_MALWARE:
       PopulateMalwareLoadTimeData(load_time_data);
       break;
-    case TYPE_HARMFUL:
+    case SB_REASON_HARMFUL:
       PopulateHarmfulLoadTimeData(load_time_data);
       break;
-    case TYPE_PHISHING:
+    case SB_REASON_PHISHING:
       PopulatePhishingLoadTimeData(load_time_data);
       break;
   }
 }
 
 void SafeBrowsingBlockingPage::PopulateExtendedReportingOption(
     base::DictionaryValue* load_time_data) {
   // Only show checkbox if !(HTTPS || incognito-mode).
   const bool show = CanShowMalwareDetailsOption();
   load_time_data->SetBoolean(kDisplayCheckBox, show);
@@ skipping 76 matching lines @@
   load_time_data->SetString(
       "explanationParagraph",
       l10n_util::GetStringFUTF16(IDS_PHISHING_V3_EXPLANATION_PARAGRAPH,
                                  GetFormattedHostName()));
   load_time_data->SetString(
       "finalParagraph",
       l10n_util::GetStringUTF16(IDS_PHISHING_V3_PROCEED_PARAGRAPH));
 
   PopulateExtendedReportingOption(load_time_data);
 }