Add finch control of user population in low reputation requests

components/safe_browsing/password_protection/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 "components/safe_browsing/password_protection/password_protection_service.h"
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/memory/ptr_util.h"
+#include "base/metrics/field_trial.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_split.h"
 #include "base/strings/string_util.h"
 #include "components/content_settings/core/browser/host_content_settings_map.h"
 #include "components/history/core/browser/history_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/v4_protocol_manager_util.h"
 #include "content/public/browser/browser_thread.h"
@@ skipping 36 matching lines @@
 // e.g., "https://www.foo.com:80/bar/test.cgi" -> "http://www.foo.com".
 GURL GetHostNameWithHTTPScheme(const GURL& url) {
   DCHECK(url.SchemeIsHTTPOrHTTPS());
   std::string result(url::kHttpScheme);
   result.append(url::kStandardSchemeSeparator).append(url.HostNoBrackets());
   return GURL(result);
 }
 
 }  // namespace
 
+const base::Feature kLowReputationPinging{"LowReputationPinging",
+                                          base::FEATURE_DISABLED_BY_DEFAULT};
+
+const base::Feature kProtectedPasswordEntryPinging{
+    "ProtectedPasswordEntryPinging", base::FEATURE_DISABLED_BY_DEFAULT};
+
 PasswordProtectionService::PasswordProtectionService(
     const scoped_refptr<SafeBrowsingDatabaseManager>& database_manager,
     scoped_refptr<net::URLRequestContextGetter> request_context_getter,
     HistoryService* history_service,
     HostContentSettingsMap* host_content_settings_map)
     : stored_verdict_count_(-1),
       database_manager_(database_manager),
       request_context_getter_(request_context_getter),
       history_service_observer_(this),
       content_settings_(host_content_settings_map),
@@ skipping 131 matching lines @@
   DCHECK(request);
   request->Start();
   requests_.insert(std::move(request));
 }
 
 void PasswordProtectionService::MaybeStartLowReputationRequest(
     const GURL& main_frame_url,
     const GURL& password_form_action,
     const GURL& password_form_frame_url) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
-  if (!IsPingingEnabled())
+  if (!IsPingingEnabled(kLowReputationPinging))
     return;
 
   // Skip URLs that we can't get a reliable reputation for.
   if (!main_frame_url.is_valid() || !main_frame_url.SchemeIsHTTPOrHTTPS()) {
     return;
   }
 
   StartRequest(main_frame_url, password_form_action, password_form_frame_url,
                LoginReputationClientRequest::UNFAMILIAR_LOGIN_PAGE);
 }
@@ skipping 65 matching lines @@
     if (verdict_dictionary.get() && !verdict_dictionary->empty())
       stored_verdict_count_ += static_cast<int>(verdict_dictionary->size());
   }
   return stored_verdict_count_;
 }
 
 int PasswordProtectionService::GetRequestTimeoutInMS() {
   return kRequestTimeoutMs;
 }
 
+void PasswordProtectionService::FillUserPopulation(
+    const LoginReputationClientRequest::TriggerType& request_type,
+    LoginReputationClientRequest* request_proto) {
+  ChromeUserPopulation* user_population = request_proto->mutable_population();
+  user_population->set_user_population(
+      IsExtendedReporting() ? ChromeUserPopulation::EXTENDED_REPORTING
+                            : ChromeUserPopulation::SAFE_BROWSING);
+  user_population->set_is_history_sync_enabled(IsHistorySyncEnabled());
+
+  base::FieldTrial* low_reputation_field_trial =
+      base::FeatureList::GetFieldTrial(kLowReputationPinging);
+  if (low_reputation_field_trial) {
+    user_population->add_finch_active_groups(
+        low_reputation_field_trial->trial_name() + "|" +
+        low_reputation_field_trial->group_name());
+  }
+  base::FieldTrial* password_entry_field_trial =
+      base::FeatureList::GetFieldTrial(kProtectedPasswordEntryPinging);
+  if (password_entry_field_trial) {
+    user_population->add_finch_active_groups(
+        low_reputation_field_trial->trial_name() + "|" +
+        low_reputation_field_trial->group_name());
+  }
+}
+
 void PasswordProtectionService::OnMatchCsdWhiteListResult(
     const bool* match_whitelist) {
   UMA_HISTOGRAM_BOOLEAN(
       "PasswordManager.PasswordReuse.MainFrameMatchCsdWhitelist",
       *match_whitelist);
 }
 
 void PasswordProtectionService::OnURLsDeleted(
     history::HistoryService* history_service,
     bool all_history,
@@ skipping 133 matching lines @@
   const std::vector<char> verdict_blob(serialized_proto.begin(),
                                        serialized_proto.end());
   std::unique_ptr<base::Value> binary_value =
       base::MakeUnique<base::Value>(verdict_blob);
   DCHECK_EQ(base::Value::Type::BINARY, binary_value->type());
   result->Set(kVerdictProto, std::move(binary_value));
   return result;
 }
 
 }  // namespace safe_browsing