Add UMA metrics to phishguard pings

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"
 #include "components/content_settings/core/browser/host_content_settings_map.h"
 #include "components/safe_browsing/password_protection/password_protection_request.h"
 #include "components/safe_browsing_db/test_database_manager.h"
 #include "components/sync_preferences/testing_pref_service_syncable.h"
 #include "content/public/test/test_browser_thread_bundle.h"
 #include "net/url_request/test_url_fetcher_factory.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace {
 
 const char kPasswordReuseMatchWhitelistHistogramName[] =
     "PasswordManager.PasswordReuse.MainFrameMatchCsdWhitelist";
 const char kWhitelistedUrl[] = "http://inwhitelist.com";
 const char kNoneWhitelistedUrl[] = "http://notinwhitelist.com";
-const char kRequestOutcomeHistogramName[] = "PasswordProtection.RequestOutcome";
 const char kTargetUrl[] = "http://foo.com";
+const char kVerdictHistogramName[] =
+    "PasswordProtection.Verdict.PasswordFieldOnFocus";
 
 }  // namespace
 
 namespace safe_browsing {
 
 class MockSafeBrowsingDatabaseManager : public TestSafeBrowsingDatabaseManager {
  public:
   MockSafeBrowsingDatabaseManager() {}
 
   MOCK_METHOD1(MatchCsdWhitelistUrl, bool(const GURL&));
@@ skipping 52 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(const base::Feature& feature) override { return true; }
+  bool IsPingingEnabled(const base::Feature& feature,
+                        RequestOutcome* reason) override {
+    return true;
+  }
 
   bool IsHistorySyncEnabled() override { return false; }
 
   LoginReputationClientResponse* latest_response() {
     return latest_response_.get();
   }
 
   ~TestPasswordProtectionService() override {}
 
   size_t GetPendingRequestsCount() { return requests_.size(); }
@@ skipping 289 matching lines @@
   // If delete all history. All password protection content settings should be
   // gone.
   password_protection_service_->RemoveContentSettingsOnURLsDeleted(
       true /* all_history */, history::URLRows());
   EXPECT_EQ(0U, GetStoredVerdictCount());
 }
 
 TEST_F(PasswordProtectionServiceTest,
        TestNoRequestCreatedIfMainFrameURLIsNotValid) {
   ASSERT_EQ(0u, password_protection_service_->GetPendingRequestsCount());
-  password_protection_service_->MaybeStartLowReputationRequest(
+  password_protection_service_->MaybeStartPasswordFieldOnFocusRequest(
       GURL(), GURL("http://foo.com/submit"), GURL("http://foo.com/frame"));
   EXPECT_EQ(0u, password_protection_service_->GetPendingRequestsCount());
 }
 
 TEST_F(PasswordProtectionServiceTest,
        TestNoRequestCreatedIfMainFrameURLIsNotHttpOrHttps) {
   ASSERT_EQ(0u, password_protection_service_->GetPendingRequestsCount());
   // If main frame url is data url, don't create request.
-  password_protection_service_->MaybeStartLowReputationRequest(
+  password_protection_service_->MaybeStartPasswordFieldOnFocusRequest(
       GURL("data:text/html, <p>hellow"), GURL("http://foo.com/submit"),
       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(
+  password_protection_service_->MaybeStartPasswordFieldOnFocusRequest(
       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, TestNoRequestSentForWhitelistedURL) {
-  histograms_.ExpectTotalCount(kRequestOutcomeHistogramName, 0);
+  histograms_.ExpectTotalCount(kPasswordOnFocusRequestOutcomeHistogramName, 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)));
+  EXPECT_THAT(
+      histograms_.GetAllSamples(kPasswordOnFocusRequestOutcomeHistogramName),
+      testing::ElementsAre(base::Bucket(4 /* MATCHED_WHITELIST */, 1)));
 }
 
 TEST_F(PasswordProtectionServiceTest, TestNoRequestSentIfVerdictAlreadyCached) {
-  histograms_.ExpectTotalCount(kRequestOutcomeHistogramName, 0);
+  histograms_.ExpectTotalCount(kPasswordOnFocusRequestOutcomeHistogramName, 0);
   CacheVerdict(GURL(kTargetUrl), LoginReputationClientResponse::LOW_REPUTATION,
                600, GURL(kTargetUrl).host(), base::Time::Now());
   InitializeAndStartRequest(false /* match whitelist */,
                             10000 /* timeout in ms*/);
   base::RunLoop().RunUntilIdle();
   EXPECT_THAT(
-      histograms_.GetAllSamples(kRequestOutcomeHistogramName),
+      histograms_.GetAllSamples(kPasswordOnFocusRequestOutcomeHistogramName),
       testing::ElementsAre(base::Bucket(5 /* RESPONSE_ALREADY_CACHED */, 1)));
   EXPECT_EQ(LoginReputationClientResponse::LOW_REPUTATION,
             password_protection_service_->latest_response()->verdict_type());
 }
 
 TEST_F(PasswordProtectionServiceTest, TestResponseFetchFailed) {
-  histograms_.ExpectTotalCount(kRequestOutcomeHistogramName, 0);
+  histograms_.ExpectTotalCount(kPasswordOnFocusRequestOutcomeHistogramName, 0);
   net::TestURLFetcher failed_fetcher(0, GURL("http://bar.com"), nullptr);
   // Set up failed response.
   failed_fetcher.set_status(
       net::URLRequestStatus(net::URLRequestStatus::FAILED, net::ERR_FAILED));
 
   InitializeAndStartRequest(false /* match whitelist */,
                             10000 /* timeout in ms*/);
   request_->OnURLFetchComplete(&failed_fetcher);
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(nullptr, password_protection_service_->latest_response());
-  EXPECT_THAT(histograms_.GetAllSamples(kRequestOutcomeHistogramName),
-              testing::ElementsAre(base::Bucket(9 /* FETCH_FAILED */, 1)));
+  EXPECT_THAT(
+      histograms_.GetAllSamples(kPasswordOnFocusRequestOutcomeHistogramName),
+      testing::ElementsAre(base::Bucket(9 /* FETCH_FAILED */, 1)));
 }
 
 TEST_F(PasswordProtectionServiceTest, TestMalformedResponse) {
-  histograms_.ExpectTotalCount(kRequestOutcomeHistogramName, 0);
+  histograms_.ExpectTotalCount(kPasswordOnFocusRequestOutcomeHistogramName, 0);
   // Set up malformed response.
   net::TestURLFetcher fetcher(0, GURL("http://bar.com"), nullptr);
   fetcher.set_status(
       net::URLRequestStatus(net::URLRequestStatus::SUCCESS, net::OK));
   fetcher.set_response_code(200);
   fetcher.SetResponseString("invalid response");
 
   InitializeAndStartRequest(false /* match whitelist */,
                             10000 /* timeout in ms*/);
   request_->OnURLFetchComplete(&fetcher);
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(nullptr, password_protection_service_->latest_response());
   EXPECT_THAT(
-      histograms_.GetAllSamples(kRequestOutcomeHistogramName),
+      histograms_.GetAllSamples(kPasswordOnFocusRequestOutcomeHistogramName),
       testing::ElementsAre(base::Bucket(10 /* RESPONSE_MALFORMED */, 1)));
 }
 
 TEST_F(PasswordProtectionServiceTest, TestRequestTimedout) {
-  histograms_.ExpectTotalCount(kRequestOutcomeHistogramName, 0);
+  histograms_.ExpectTotalCount(kPasswordOnFocusRequestOutcomeHistogramName, 0);
   InitializeAndStartRequest(false /* match whitelist */,
                             0 /* timeout immediately */);
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(nullptr, password_protection_service_->latest_response());
-  EXPECT_THAT(histograms_.GetAllSamples(kRequestOutcomeHistogramName),
-              testing::ElementsAre(base::Bucket(3 /* TIMEDOUT */, 1)));
+  EXPECT_THAT(
+      histograms_.GetAllSamples(kPasswordOnFocusRequestOutcomeHistogramName),
+      testing::ElementsAre(base::Bucket(3 /* TIMEDOUT */, 1)));
 }
 
 TEST_F(PasswordProtectionServiceTest, TestRequestAndResponseSuccessfull) {
-  histograms_.ExpectTotalCount(kRequestOutcomeHistogramName, 0);
+  histograms_.ExpectTotalCount(kPasswordOnFocusRequestOutcomeHistogramName, 0);
   // Set up valid response.
   net::TestURLFetcher fetcher(0, GURL("http://bar.com"), nullptr);
   fetcher.set_status(
       net::URLRequestStatus(net::URLRequestStatus::SUCCESS, net::OK));
   fetcher.set_response_code(200);
   LoginReputationClientResponse expected_response = CreateVerdictProto(
       LoginReputationClientResponse::PHISHING, 600, GURL(kTargetUrl).host());
   fetcher.SetResponseString(expected_response.SerializeAsString());
 
   InitializeAndStartRequest(false /* match whitelist */,
                             10000 /* timeout in ms*/);
   request_->OnURLFetchComplete(&fetcher);
   base::RunLoop().RunUntilIdle();
-  EXPECT_THAT(histograms_.GetAllSamples(kRequestOutcomeHistogramName),
-              testing::ElementsAre(base::Bucket(1 /* SUCCEEDED */, 1)));
+  EXPECT_THAT(
+      histograms_.GetAllSamples(kPasswordOnFocusRequestOutcomeHistogramName),
+      testing::ElementsAre(base::Bucket(1 /* SUCCEEDED */, 1)));
+  EXPECT_THAT(histograms_.GetAllSamples(kVerdictHistogramName),
+              testing::ElementsAre(base::Bucket(3 /* PHISHING */, 1)));
   LoginReputationClientResponse* actual_response =
       password_protection_service_->latest_response();
   EXPECT_EQ(expected_response.verdict_type(), actual_response->verdict_type());
   EXPECT_EQ(expected_response.cache_expression(),
             actual_response->cache_expression());
   EXPECT_EQ(expected_response.cache_duration_sec(),
             actual_response->cache_duration_sec());
 }
 
 TEST_F(PasswordProtectionServiceTest, TestTearDownWithPendingRequests) {
-  histograms_.ExpectTotalCount(kRequestOutcomeHistogramName, 0);
+  histograms_.ExpectTotalCount(kPasswordOnFocusRequestOutcomeHistogramName, 0);
   GURL target_url(kTargetUrl);
   EXPECT_CALL(*database_manager_.get(), MatchCsdWhitelistUrl(target_url))
       .WillRepeatedly(testing::Return(false));
   password_protection_service_->StartRequest(
       target_url, GURL("http://foo.com/submit"), GURL("http://foo.com/frame"),
       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)));
+  EXPECT_THAT(
+      histograms_.GetAllSamples(kPasswordOnFocusRequestOutcomeHistogramName),
+      testing::ElementsAre(base::Bucket(2 /* CANCELED */, 1)));
 }
 
 TEST_F(PasswordProtectionServiceTest, TestCleanUpExpiredVerdict) {
   ASSERT_EQ(0U, GetStoredVerdictCount());
   // Prepare 4 verdicts:
   // (1) "foo.com/abc" valid
   // (2) "foo.com/def" expired
   // (3) "bar.com/abc" expired
   // (4) "bar.com/def" expired
   base::Time now = base::Time::Now();
@@ skipping 21 matching lines @@
   EXPECT_EQ(LoginReputationClientResponse::VERDICT_TYPE_UNSPECIFIED,
             password_protection_service_->GetCachedVerdict(
                 GURL("https://foo.com/def/index.jsp"), &actual_verdict));
   // Nothing in content setting for bar.com.
   EXPECT_EQ(nullptr, content_setting_map_->GetWebsiteSetting(
                          GURL("https://bar.com"), GURL(),
                          CONTENT_SETTINGS_TYPE_PASSWORD_PROTECTION,
                          std::string(), nullptr));
 }
 }  // namespace safe_browsing