Add UMA metrics to phishguard pings

components/safe_browsing/password_protection/password_protection_request.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_request.h"
 
 #include "base/memory/ptr_util.h"
 #include "base/memory/weak_ptr.h"
 #include "base/metrics/histogram_macros.h"
 #include "components/data_use_measurement/core/data_use_user_data.h"
 #include "components/safe_browsing_db/database_manager.h"
@@ skipping 42 matching lines @@
                  base::Unretained(password_protection_service_),
                  main_frame_url_, match_whitelist),
       base::Bind(&PasswordProtectionRequest::OnWhitelistCheckDone, this,
                  base::Owned(match_whitelist)));
 }
 
 void PasswordProtectionRequest::OnWhitelistCheckDone(
     const bool* match_whitelist) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   if (*match_whitelist)
-    Finish(RequestOutcome::MATCHED_WHITELIST, nullptr);
+    Finish(PasswordProtectionService::MATCHED_WHITELIST, nullptr);
   else
     CheckCachedVerdicts();
 }
 
 void PasswordProtectionRequest::CheckCachedVerdicts() {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   if (!password_protection_service_) {
-    Finish(RequestOutcome::SERVICE_DESTROYED, nullptr);
+    Finish(PasswordProtectionService::SERVICE_DESTROYED, nullptr);
     return;
   }
 
   std::unique_ptr<LoginReputationClientResponse> cached_response =
       base::MakeUnique<LoginReputationClientResponse>();
   auto verdict = password_protection_service_->GetCachedVerdict(
       main_frame_url_, cached_response.get());
   if (verdict != LoginReputationClientResponse::VERDICT_TYPE_UNSPECIFIED)
-    Finish(RequestOutcome::RESPONSE_ALREADY_CACHED, std::move(cached_response));
+    Finish(PasswordProtectionService::RESPONSE_ALREADY_CACHED,
+           std::move(cached_response));
   else
     SendRequest();
 }
 
 void PasswordProtectionRequest::FillRequestProto() {
   request_proto_ = base::MakeUnique<LoginReputationClientRequest>();
   request_proto_->set_page_url(main_frame_url_.spec());
   request_proto_->set_trigger_type(request_type_);
   password_protection_service_->FillUserPopulation(request_type_,
                                                    request_proto_.get());
@@ skipping 22 matching lines @@
   // TODO(jialiul): Fill more frame specific info when Safe Browsing backend
   // is ready to handle these pieces of information.
 }
 
 void PasswordProtectionRequest::SendRequest() {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   FillRequestProto();
 
   std::string serialized_request;
   if (!request_proto_->SerializeToString(&serialized_request)) {
-    Finish(RequestOutcome::REQUEST_MALFORMED, nullptr);
+    Finish(PasswordProtectionService::REQUEST_MALFORMED, nullptr);
     return;
   }
 
   // In case the request take too long, we set a timer to cancel this request.
   StartTimeout();
 
   fetcher_ = net::URLFetcher::Create(
       0, PasswordProtectionService::GetPasswordProtectionRequestUrl(),
       net::URLFetcher::POST, this);
   data_use_measurement::DataUseUserData::AttachToFetcher(
@@ skipping 25 matching lines @@
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   net::URLRequestStatus status = source->GetStatus();
   const bool is_success = status.is_success();
   const int response_code = source->GetResponseCode();
 
   UMA_HISTOGRAM_SPARSE_SLOWLY(
       "PasswordProtection.PasswordProtectionResponseOrErrorCode",
       is_success ? response_code : status.error());
 
   if (!is_success || net::HTTP_OK != response_code) {
-    Finish(RequestOutcome::FETCH_FAILED, nullptr);
+    Finish(PasswordProtectionService::FETCH_FAILED, nullptr);
     return;
   }
 
   std::unique_ptr<LoginReputationClientResponse> response =
       base::MakeUnique<LoginReputationClientResponse>();
   std::string response_body;
   bool received_data = source->GetResponseAsString(&response_body);
   DCHECK(received_data);
   fetcher_.reset();  // We don't need it anymore.
   UMA_HISTOGRAM_TIMES("PasswordProtection.RequestNetworkDuration",
                       base::TimeTicks::Now() - request_start_time_);
   if (response->ParseFromString(response_body))
-    Finish(RequestOutcome::SUCCEEDED, std::move(response));
+    Finish(PasswordProtectionService::SUCCEEDED, std::move(response));
   else
-    Finish(RequestOutcome::RESPONSE_MALFORMED, nullptr);
+    Finish(PasswordProtectionService::RESPONSE_MALFORMED, nullptr);
 }
 
 void PasswordProtectionRequest::Finish(
-    RequestOutcome outcome,
+    PasswordProtectionService::RequestOutcome outcome,
     std::unique_ptr<LoginReputationClientResponse> response) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   tracker_.TryCancelAll();
 
-  UMA_HISTOGRAM_ENUMERATION("PasswordProtection.RequestOutcome", outcome,
-                            RequestOutcome::MAX_OUTCOME);
+  if (request_type_ == LoginReputationClientRequest::UNFAMILIAR_LOGIN_PAGE) {
+    UMA_HISTOGRAM_ENUMERATION(kPasswordOnFocusRequestOutcomeHistogramName,
+                              outcome, PasswordProtectionService::MAX_OUTCOME);
+  } else {
+    UMA_HISTOGRAM_ENUMERATION(kPasswordEntryRequestOutcomeHistogramName,
+                              outcome, PasswordProtectionService::MAX_OUTCOME);
+  }
 
   if (response) {
     switch (request_type_) {
       case LoginReputationClientRequest::UNFAMILIAR_LOGIN_PAGE:
         UMA_HISTOGRAM_ENUMERATION(
-            "PasswordProtection.UnfamiliarLoginPageVerdict",
+            "PasswordProtection.Verdict.PasswordFieldOnFocus",
             response->verdict_type(),
             LoginReputationClientResponse_VerdictType_VerdictType_MAX + 1);
         break;
       case LoginReputationClientRequest::PASSWORD_REUSE_EVENT:
         UMA_HISTOGRAM_ENUMERATION(
-            "PasswordProtection.PasswordReuseEventVerdict",
+            "PasswordProtection.Verdict.ProtectedPasswordEntry",
             response->verdict_type(),
             LoginReputationClientResponse_VerdictType_VerdictType_MAX + 1);
         break;
       default:
         NOTREACHED();
     }
   }
 
   DCHECK(password_protection_service_);
   password_protection_service_->RequestFinished(this, std::move(response));
 }
 
 void PasswordProtectionRequest::Cancel(bool timed_out) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   fetcher_.reset();
 
-  Finish(timed_out ? TIMEDOUT : CANCELED, nullptr);
+  Finish(timed_out ? PasswordProtectionService::TIMEDOUT
+                   : PasswordProtectionService::CANCELED,
+         nullptr);
 }
 
 }  // namespace safe_browsing