Add finch control of user population in low reputation requests

chrome/browser/safe_browsing/chrome_password_protection_service.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 "chrome/browser/safe_browsing/chrome_password_protection_service.h"
 
 #include "base/feature_list.h"
+#include "base/metrics/field_trial_params.h"
 #include "base/metrics/histogram_macros.h"
 #include "chrome/browser/content_settings/host_content_settings_map_factory.h"
 #include "chrome/browser/history/history_service_factory.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/safe_browsing/safe_browsing_navigation_observer_manager.h"
 #include "chrome/browser/safe_browsing/safe_browsing_service.h"
+#include "chrome/browser/sync/profile_sync_service_factory.h"
+#include "components/browser_sync/profile_sync_service.h"
+#include "components/safe_browsing/password_protection/password_protection_request.h"
+#include "components/safe_browsing_db/database_manager.h"
 #include "components/safe_browsing_db/safe_browsing_prefs.h"
 
 using content::BrowserThread;
 
 namespace safe_browsing {
 
 namespace {
 // The number of user gestures we trace back for login event attribution.
 const int kPasswordEventAttributionUserGestureLimit = 2;
 }
 
-const base::Feature kPasswordProtectionPingOnly{
-    "PasswordProtectionPingOnly", base::FEATURE_DISABLED_BY_DEFAULT};
-
 ChromePasswordProtectionService::ChromePasswordProtectionService(
     SafeBrowsingService* sb_service,
     Profile* profile)
     : PasswordProtectionService(
           sb_service->database_manager(),
           sb_service->url_request_context(),
           HistoryServiceFactory::GetForProfile(
               profile,
               ServiceAccessType::EXPLICIT_ACCESS),
           HostContentSettingsMapFactory::GetForProfile(profile)),
       profile_(profile),
       navigation_observer_manager_(sb_service->navigation_observer_manager()) {
   DCHECK(profile_);
 }
 
 ChromePasswordProtectionService::~ChromePasswordProtectionService() {
-  UMA_HISTOGRAM_COUNTS_1000(
-      "PasswordProtection.NumberOfCachedVerdictBeforeShutdown",
-      GetStoredVerdictCount());
+  if (content_settings()) {
+    UMA_HISTOGRAM_COUNTS_1000(
+        "PasswordProtection.NumberOfCachedVerdictBeforeShutdown",
+        GetStoredVerdictCount());
+  }
 }
 
 void ChromePasswordProtectionService::FillReferrerChain(
     const GURL& event_url,
     int event_tab_id,
     LoginReputationClientRequest::Frame* frame) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   SafeBrowsingNavigationObserverManager::AttributionResult result =
       navigation_observer_manager_->IdentifyReferrerChainByEventURL(
           event_url, event_tab_id, kPasswordEventAttributionUserGestureLimit,
           frame->mutable_referrer_chain());
   UMA_HISTOGRAM_COUNTS_100(
       "SafeBrowsing.ReferrerURLChainSize.PasswordEventAttribution",
       frame->referrer_chain().size());
   UMA_HISTOGRAM_ENUMERATION(
       "SafeBrowsing.ReferrerAttributionResult.PasswordEventAttribution", result,
       SafeBrowsingNavigationObserverManager::ATTRIBUTION_FAILURE_TYPE_MAX);
 }
 
 bool ChromePasswordProtectionService::IsExtendedReporting() {
   return IsExtendedReportingEnabled(*profile_->GetPrefs());
 }
 
 bool ChromePasswordProtectionService::IsIncognito() {
   DCHECK(profile_);
   return profile_->IsOffTheRecord();
 }
 
-bool ChromePasswordProtectionService::IsPingingEnabled() {
-  return base::FeatureList::IsEnabled(kPasswordProtectionPingOnly);
+bool ChromePasswordProtectionService::IsPingingEnabled(
+    const base::Feature& feature) {
+  if (!base::FeatureList::IsEnabled(feature)) {
+    return false;
+  }
+
+  bool allowed_incognito =
+      base::GetFieldTrialParamByFeatureAsBool(feature, "incognito", false);
+  if (IsIncognito() && !allowed_incognito)
+    return false;
+
+  bool allowed_all_population =
+      base::GetFieldTrialParamByFeatureAsBool(feature, "all_population", false);
+  if (!allowed_all_population) {

[Nathan Parker, 2017/05/05 22:51:41]

nit (or not, you decide which you like better):

if (allowed_all_poplation)
  return true;
...
...
return false.

[Jialiu Lin, 2017/05/05 22:58:51]

Acknowledged.

+    bool allowed_extended_reporting = base::GetFieldTrialParamByFeatureAsBool(
+        feature, "extended_reporting", false);
+    if (IsExtendedReporting() && allowed_extended_reporting)
+      return true;  // Ping enabled because this user opted in extended
+                    // reporting.
+
+    bool allowed_history_sync =
+        base::GetFieldTrialParamByFeatureAsBool(feature, "history_sync", false);
+    if (IsHistorySyncEnabled() && allowed_history_sync)
+      return true;
+  }
+
+  return allowed_all_population;
 }
 
+bool ChromePasswordProtectionService::IsHistorySyncEnabled() {
+  browser_sync::ProfileSyncService* sync =
+      ProfileSyncServiceFactory::GetInstance()->GetForProfile(profile_);
+  return sync && sync->IsSyncActive() && !sync->IsLocalSyncEnabled() &&
+         sync->GetActiveDataTypes().Has(syncer::HISTORY_DELETE_DIRECTIVES);
+}
+
+ChromePasswordProtectionService::ChromePasswordProtectionService()
+    : PasswordProtectionService(nullptr, nullptr, nullptr, nullptr) {}
 }  // namespace safe_browsing