Fill has_password_field for password reuse ping

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/base64.h"
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/memory/ptr_util.h"
@@ skipping 254 matching lines @@
     }
   }
 }
 
 void PasswordProtectionService::StartRequest(
     WebContents* web_contents,
     const GURL& main_frame_url,
     const GURL& password_form_action,
     const GURL& password_form_frame_url,
     const std::string& saved_domain,
-    LoginReputationClientRequest::TriggerType type) {
+    LoginReputationClientRequest::TriggerType type,
+    bool password_field_exists) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   scoped_refptr<PasswordProtectionRequest> request(
-      new PasswordProtectionRequest(web_contents, main_frame_url,
-                                    password_form_action,
-                                    password_form_frame_url, saved_domain, type,
-                                    this, GetRequestTimeoutInMS()));
+      new PasswordProtectionRequest(
+          web_contents, main_frame_url, password_form_action,
+          password_form_frame_url, saved_domain, type, password_field_exists,
+          this, GetRequestTimeoutInMS()));
   DCHECK(request);
   request->Start();
   requests_.insert(std::move(request));
 }
 
 void PasswordProtectionService::MaybeStartPasswordFieldOnFocusRequest(
     WebContents* web_contents,
     const GURL& main_frame_url,
     const GURL& password_form_action,
     const GURL& password_form_frame_url) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   if (CanSendPing(kPasswordFieldOnFocusPinging, main_frame_url)) {
     StartRequest(web_contents, main_frame_url, password_form_action,
                  password_form_frame_url,
                  std::string(), /* saved_domain: not used for this type */
-                 LoginReputationClientRequest::UNFAMILIAR_LOGIN_PAGE);
+                 LoginReputationClientRequest::UNFAMILIAR_LOGIN_PAGE, true);
   }
 }
 
 void PasswordProtectionService::MaybeStartProtectedPasswordEntryRequest(
     WebContents* web_contents,
     const GURL& main_frame_url,
-    const std::string& saved_domain) {
+    const std::string& saved_domain,
+    bool password_field_exists) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   if (CanSendPing(kProtectedPasswordEntryPinging, main_frame_url)) {
     StartRequest(web_contents, main_frame_url, GURL(), GURL(), saved_domain,
-                 LoginReputationClientRequest::PASSWORD_REUSE_EVENT);
+                 LoginReputationClientRequest::PASSWORD_REUSE_EVENT,
+                 password_field_exists);
   }
 }
 
 bool PasswordProtectionService::CanSendPing(const base::Feature& feature,
                                             const GURL& main_frame_url) {
   RequestOutcome request_outcome = URL_NOT_VALID_FOR_REPUTATION_COMPUTING;
   if (IsPingingEnabled(kPasswordFieldOnFocusPinging, &request_outcome) &&
       CanGetReputationOfURL(main_frame_url)) {
     return true;
   }
@@ skipping 263 matching lines @@
   if (is_password_entry_ping) {
     UMA_HISTOGRAM_ENUMERATION(kPasswordEntryRequestOutcomeHistogramName, reason,
                               MAX_OUTCOME);
   } else {
     UMA_HISTOGRAM_ENUMERATION(kPasswordOnFocusRequestOutcomeHistogramName,
                               reason, MAX_OUTCOME);
   }
 }
 
 }  // namespace safe_browsing