Add UMA metrics to phishguard pings

components/safe_browsing/password_protection/password_protection_service.h

 // 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.
 
 #ifndef COMPONENTS_SAFE_BROWSING_PASSWORD_PROTECTION_PASSWORD_PROTECTION_SERVICE_H_
 #define COMPONENTS_SAFE_BROWSING_PASSWORD_PROTECTION_PASSWORD_PROTECTION_SERVICE_H_
 
 #include <set>
 
 #include "base/callback.h"
@@ skipping 17 matching lines @@
 class GURL;
 class HostContentSettingsMap;
 
 namespace safe_browsing {
 
 class SafeBrowsingDatabaseManager;
 class PasswordProtectionRequest;
 
 extern const base::Feature kPasswordFieldOnFocusPinging;
 extern const base::Feature kProtectedPasswordEntryPinging;
+extern const char kPasswordOnFocusRequestOutcomeHistogramName[];
+extern const char kPasswordEntryRequestOutcomeHistogramName[];
 
 // Manage password protection pings and verdicts. There is one instance of this
 // class per profile. Therefore, every PasswordProtectionService instance is
 // associated with a unique HistoryService instance and a unique
 // HostContentSettingsMap instance.
 class PasswordProtectionService : public history::HistoryServiceObserver {
  public:
+  // The outcome of the request. These values are used for UMA.
+  // DO NOT CHANGE THE ORDERING OF THESE VALUES.
+  enum RequestOutcome {
+    UNKNOWN = 0,
+    SUCCEEDED = 1,
+    CANCELED = 2,
+    TIMEDOUT = 3,
+    MATCHED_WHITELIST = 4,
+    RESPONSE_ALREADY_CACHED = 5,
+    DEPRECATED_NO_EXTENDED_REPORTING = 6,
+    DISABLED_DUE_TO_INCOGNITO = 7,
+    REQUEST_MALFORMED = 8,
+    FETCH_FAILED = 9,
+    RESPONSE_MALFORMED = 10,
+    SERVICE_DESTROYED = 11,
+    DISABLED_DUE_TO_FEATURE_DISABLED = 12,
+    DISABLED_DUE_TO_USER_POPULATION = 13,
+    MAX_OUTCOME
+  };
   PasswordProtectionService(
       const scoped_refptr<SafeBrowsingDatabaseManager>& database_manager,
       scoped_refptr<net::URLRequestContextGetter> request_context_getter,
       history::HistoryService* history_service,
       HostContentSettingsMap* host_content_settings_map);
 
   ~PasswordProtectionService() override;
 
   base::WeakPtr<PasswordProtectionService> GetWeakPtr() {
     return weak_factory_.GetWeakPtr();
@@ skipping 20 matching lines @@
   void CleanUpExpiredVerdicts();
 
   // Creates an instance of PasswordProtectionRequest and call Start() on that
   // instance. This function also insert this request object in |requests_| for
   // record keeping.
   void StartRequest(const GURL& main_frame_url,
                     const GURL& password_form_action,
                     const GURL& password_form_frame_url,
                     LoginReputationClientRequest::TriggerType type);
 
-  virtual void MaybeStartLowReputationRequest(
+  virtual void MaybeStartPasswordFieldOnFocusRequest(
       const GURL& main_frame_url,
       const GURL& password_form_action,
       const GURL& password_form_frame_url);
 
   scoped_refptr<SafeBrowsingDatabaseManager> database_manager();
 
  protected:
   friend class PasswordProtectionRequest;
 
   // Called by a PasswordProtectionRequest instance when it finishes to remove
@@ skipping 28 matching lines @@
       LoginReputationClientRequest::Frame* frame) = 0;
 
   void FillUserPopulation(
       const LoginReputationClientRequest::TriggerType& request_type,
       LoginReputationClientRequest* request_proto);
 
   virtual bool IsExtendedReporting() = 0;
 
   virtual bool IsIncognito() = 0;
 
-  virtual bool IsPingingEnabled(const base::Feature& feature) = 0;
+  virtual bool IsPingingEnabled(const base::Feature& feature,
+                                RequestOutcome* reason) = 0;
 
   virtual bool IsHistorySyncEnabled() = 0;
 
   void CheckCsdWhitelistOnIOThread(const GURL& url, bool* check_result);
 
   // Increases "PasswordManager.PasswordReuse.MainFrameMatchCsdWhitelist" UMA
   // metric based on input.
   void OnMatchCsdWhiteListResult(const bool* match_whitelist);
 
   HostContentSettingsMap* content_settings() const { return content_settings_; }
@@ skipping 40 matching lines @@
   static void GeneratePathVariantsWithoutQuery(const GURL& url,
                                                std::vector<std::string>* paths);
 
   static std::string GetCacheExpressionPath(
       const std::string& cache_expression);
 
   static std::unique_ptr<base::DictionaryValue> CreateDictionaryFromVerdict(
       const LoginReputationClientResponse* verdict,
       const base::Time& receive_time);
 
+  static void RecordPingingDisabledReason(const base::Feature& feature,
+                                          RequestOutcome reason);
   // Number of verdict stored for this profile.
   int stored_verdict_count_;
 
   scoped_refptr<SafeBrowsingDatabaseManager> database_manager_;
 
   // The context we use to issue network requests. This request_context_getter
   // is obtained from SafeBrowsingService so that we can use the Safe Browsing
   // cookie store.
   scoped_refptr<net::URLRequestContextGetter> request_context_getter_;
 
@@ skipping 10 matching lines @@
   // we need CancelableTaskTracker to cancel tasks posted to IO thread.
   base::CancelableTaskTracker tracker_;
 
   base::WeakPtrFactory<PasswordProtectionService> weak_factory_;
   DISALLOW_COPY_AND_ASSIGN(PasswordProtectionService);
 };
 
 }  // namespace safe_browsing
 
 #endif  // COMPONENTS_SAFE_BROWSING_PASSWORD_PROTECTION_PASSWORD_PROTECTION_SERVICE_H_