Trigger protected password entry request on password reuse event.

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 80 matching lines @@
     history_service_observer_.Add(history_service);
 }
 
 PasswordProtectionService::~PasswordProtectionService() {
   tracker_.TryCancelAll();
   CancelPendingRequests();
   history_service_observer_.RemoveAll();
   weak_factory_.InvalidateWeakPtrs();
 }
 
-void PasswordProtectionService::RecordPasswordReuse(const GURL& url) {
-  DCHECK_CURRENTLY_ON(BrowserThread::UI);
-  DCHECK(database_manager_);
-  bool* match_whitelist = new bool(false);
-  tracker_.PostTaskAndReply(
-      BrowserThread::GetTaskRunnerForThread(BrowserThread::IO).get(), FROM_HERE,
-      base::Bind(&PasswordProtectionService::CheckCsdWhitelistOnIOThread,
-                 base::Unretained(this), url, match_whitelist),
-      base::Bind(&PasswordProtectionService::OnMatchCsdWhiteListResult,
-                 base::Unretained(this), base::Owned(match_whitelist)));
-}
-
 void PasswordProtectionService::CheckCsdWhitelistOnIOThread(
     const GURL& url,
     bool* check_result) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   *check_result =
       url.is_valid() ? database_manager_->MatchCsdWhitelistUrl(url) : true;
 }
 
 LoginReputationClientResponse::VerdictType
 PasswordProtectionService::GetCachedVerdict(
@@ skipping 136 matching lines @@
           CONTENT_SETTINGS_TYPE_PASSWORD_PROTECTION, std::string(),
           std::move(verdict_dictionary));
     }
   }
 }
 
 void PasswordProtectionService::StartRequest(
     const GURL& main_frame_url,
     const GURL& password_form_action,
     const GURL& password_form_frame_url,
+    const std::string& saved_domain,
     LoginReputationClientRequest::TriggerType type) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   scoped_refptr<PasswordProtectionRequest> request(
       new PasswordProtectionRequest(main_frame_url, password_form_action,
-                                    password_form_frame_url, type, this,
-                                    GetRequestTimeoutInMS()));
+                                    password_form_frame_url, saved_domain, type,
+                                    this, GetRequestTimeoutInMS()));
   DCHECK(request);
   request->Start();
   requests_.insert(std::move(request));
 }
 
 void PasswordProtectionService::MaybeStartPasswordFieldOnFocusRequest(
     const GURL& main_frame_url,
     const GURL& password_form_action,
     const GURL& password_form_frame_url) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   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,
+               std::string(), /* saved_domain: not used for this type */
                LoginReputationClientRequest::UNFAMILIAR_LOGIN_PAGE);
 }
 
+void PasswordProtectionService::MaybeStartProtectedPasswordEntryRequest(
+    const GURL& main_frame_url,
+    const std::string& saved_domain) {
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
+  RequestOutcome request_outcome;
+  if (!IsPingingEnabled(kProtectedPasswordEntryPinging, &request_outcome)) {
+    RecordPingingDisabledReason(kProtectedPasswordEntryPinging,
+                                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, GURL(), GURL(), saved_domain,
+               LoginReputationClientRequest::PASSWORD_REUSE_EVENT);
+}
+
 void PasswordProtectionService::RequestFinished(
     PasswordProtectionRequest* request,
     std::unique_ptr<LoginReputationClientResponse> response) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   DCHECK(request);
   // TODO(jialiul): We don't cache verdict for incognito mode for now.
   // Later we may consider temporarily caching verdict.
   if (response && !IsIncognito())
     CacheVerdict(request->main_frame_url(), response.get(), base::Time::Now());
@@ skipping 79 matching lines @@
   }
   base::FieldTrial* password_entry_field_trial =
       base::FeatureList::GetFieldTrial(kProtectedPasswordEntryPinging);
   if (password_entry_field_trial) {
     user_population->add_finch_active_groups(
         low_reputation_field_trial->trial_name() + "|" +
         low_reputation_field_trial->group_name());
   }
 }
 
-void PasswordProtectionService::OnMatchCsdWhiteListResult(
-    const bool* match_whitelist) {
-  UMA_HISTOGRAM_BOOLEAN(
-      "PasswordManager.PasswordReuse.MainFrameMatchCsdWhitelist",
-      *match_whitelist);
-}
-
 void PasswordProtectionService::OnURLsDeleted(
     history::HistoryService* history_service,
     bool all_history,
     bool expired,
     const history::URLRows& deleted_rows,
     const std::set<GURL>& favicon_urls) {
+  if (stored_verdict_count_ <= 0)
+    return;
+
   BrowserThread::PostTask(
       BrowserThread::UI, FROM_HERE,
       base::Bind(&PasswordProtectionService::RemoveContentSettingsOnURLsDeleted,
                  GetWeakPtr(), all_history, deleted_rows));
 }
 
 void PasswordProtectionService::HistoryServiceBeingDeleted(
     history::HistoryService* history_service) {
   history_service_observer_.RemoveAll();
 }
@@ skipping 138 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