Add UMA metrics to phishguard pings

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"
@@ skipping 52 matching lines @@
 }
 
 }  // namespace
 
 const base::Feature kPasswordFieldOnFocusPinging{
     "PasswordFieldOnFocusPinging", base::FEATURE_DISABLED_BY_DEFAULT};
 
 const base::Feature kProtectedPasswordEntryPinging{
     "ProtectedPasswordEntryPinging", base::FEATURE_DISABLED_BY_DEFAULT};
 
+const char kPasswordOnFocusRequestOutcomeHistogramName[] =
+    "PasswordProtection.RequestOutcome.PasswordFieldOnFocus";
+const char kPasswordEntryRequestOutcomeHistogramName[] =
+    "PasswordProtection.RequestOutcome.ProtectedPasswordEntry";
+
 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 182 matching lines @@
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   scoped_refptr<PasswordProtectionRequest> request(
       new PasswordProtectionRequest(main_frame_url, password_form_action,
                                     password_form_frame_url, type, this,
                                     GetRequestTimeoutInMS()));
   DCHECK(request);
   request->Start();
   requests_.insert(std::move(request));
 }
 
-void PasswordProtectionService::MaybeStartLowReputationRequest(
+void PasswordProtectionService::MaybeStartPasswordFieldOnFocusRequest(
     const GURL& main_frame_url,
     const GURL& password_form_action,
     const GURL& password_form_frame_url) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
-  if (!IsPingingEnabled(kPasswordFieldOnFocusPinging))
+  RequestOutcome request_outcome;
+  if (!IsPingingEnabled(kPasswordFieldOnFocusPinging, &request_outcome)) {
+    RecordPingingDisabledReason(kPasswordFieldOnFocusPinging, request_outcome);
     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 241 matching lines @@
   const std::string serialized_proto(verdict->SerializeAsString());
   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;
 }
 
+void PasswordProtectionService::RecordPingingDisabledReason(
+    const base::Feature& feature,
+    RequestOutcome reason) {
+  DCHECK(feature.name == kProtectedPasswordEntryPinging.name ||
+         feature.name == kPasswordFieldOnFocusPinging.name);
+
+  bool is_password_entry_ping =
+      feature.name == kProtectedPasswordEntryPinging.name;
+
+  if (is_password_entry_ping) {
+    UMA_HISTOGRAM_ENUMERATION(kPasswordEntryRequestOutcomeHistogramName, reason,
+                              MAX_OUTCOME);
+  } else {
+    UMA_HISTOGRAM_ENUMERATION(kPasswordOnFocusRequestOutcomeHistogramName,
+                              reason, MAX_OUTCOME);
+  }
+}
+
 }  // namespace safe_browsing