Add finch control of user population in low reputation requests

components/safe_browsing/password_protection/password_protection_service_unittest.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/memory/ptr_util.h"
 #include "base/run_loop.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/test/histogram_tester.h"
 #include "base/test/null_task_runner.h"
@@ skipping 79 matching lines @@
   bool IsExtendedReporting() override { return is_extended_reporting_; }
 
   bool IsIncognito() override { return is_incognito_; }
 
   void set_extended_reporting(bool enabled) {
     is_extended_reporting_ = enabled;
   }
 
   void set_incognito(bool enabled) { is_incognito_ = enabled; }
 
-  bool IsPingingEnabled() override { return true; }
+  bool IsPingingEnabled(const base::Feature& feature) override { return true; }
+
+  bool IsHistorySyncEnabled() override { return false; }
 
   LoginReputationClientResponse* latest_response() {
     return latest_response_.get();
   }
 
   ~TestPasswordProtectionService() override {}
 
   size_t GetPendingRequestsCount() { return requests_.size(); }
 
  private:
@@ skipping 306 matching lines @@
       GURL("http://foo.com/frame"));
   EXPECT_EQ(0u, password_protection_service_->GetPendingRequestsCount());
 
   // If main frame url is ftp, don't create request.
   password_protection_service_->MaybeStartLowReputationRequest(
       GURL("ftp://foo.com:21"), GURL("http://foo.com/submit"),
       GURL("http://foo.com/frame"));
   EXPECT_EQ(0u, password_protection_service_->GetPendingRequestsCount());
 }
 
-TEST_F(PasswordProtectionServiceTest, TestNoRequestSentForIncognito) {
-  histograms_.ExpectTotalCount(kRequestOutcomeHistogramName, 0);
-  password_protection_service_->set_incognito(true);
-  password_protection_service_->StartRequest(
-      GURL(kTargetUrl), GURL("http://foo.com/submit"),
-      GURL("http://foo.com/frame"),
-      LoginReputationClientRequest::UNFAMILIAR_LOGIN_PAGE);
-  base::RunLoop().RunUntilIdle();
-  EXPECT_EQ(nullptr, password_protection_service_->latest_response());
-  EXPECT_THAT(histograms_.GetAllSamples(kRequestOutcomeHistogramName),
-              testing::ElementsAre(base::Bucket(7 /* INCOGNITO */, 1)));
-}
-
-TEST_F(PasswordProtectionServiceTest,
-       TestNoRequestSentForNonExtendedReporting) {
-  histograms_.ExpectTotalCount(kRequestOutcomeHistogramName, 0);
-  password_protection_service_->set_extended_reporting(false);
-  password_protection_service_->StartRequest(
-      GURL(kTargetUrl), GURL("http://foo.com/submit"),
-      GURL("http://foo.com/frame"),
-      LoginReputationClientRequest::UNFAMILIAR_LOGIN_PAGE);
-
-  base::RunLoop().RunUntilIdle();
-  EXPECT_EQ(nullptr, password_protection_service_->latest_response());
-  EXPECT_THAT(
-      histograms_.GetAllSamples(kRequestOutcomeHistogramName),
-      testing::ElementsAre(base::Bucket(6 /* NO_EXTENDED_REPORTING */, 1)));
-}
-
 TEST_F(PasswordProtectionServiceTest, TestNoRequestSentForWhitelistedURL) {
   histograms_.ExpectTotalCount(kRequestOutcomeHistogramName, 0);
   InitializeAndStartRequest(true /* match whitelist */,
                             10000 /* timeout in ms*/);
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(nullptr, password_protection_service_->latest_response());
   EXPECT_THAT(histograms_.GetAllSamples(kRequestOutcomeHistogramName),
               testing::ElementsAre(base::Bucket(4 /* MATCHED_WHITELIST */, 1)));
 }
 
@@ skipping 92 matching lines @@
       LoginReputationClientRequest::UNFAMILIAR_LOGIN_PAGE);
 
   // Destroy password_protection_service_ while there is one request pending.
   password_protection_service_.reset();
   base::RunLoop().RunUntilIdle();
 
   EXPECT_THAT(histograms_.GetAllSamples(kRequestOutcomeHistogramName),
               testing::ElementsAre(base::Bucket(2 /* CANCELED */, 1)));
 }
 }  // namespace safe_browsing