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 243 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& legitimate_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, legitimate_domain,
+                                    type, this, GetRequestTimeoutInMS()));
   DCHECK(request);
   request->Start();
   requests_.insert(std::move(request));
 }
 
 void PasswordProtectionService::MaybeStartLowReputationRequest(
     const GURL& main_frame_url,
     const GURL& password_form_action,
     const GURL& password_form_frame_url) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   if (!IsPingingEnabled(kPasswordFieldOnFocusPinging))
     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(),

[Nathan Parker, 2017/05/12 22:28:00]

/* legitimate_domain: not used for this type */

[Jialiu Lin, 2017/05/13 00:24:12]

Done.

                LoginReputationClientRequest::UNFAMILIAR_LOGIN_PAGE);
 }
 
+void PasswordProtectionService::MaybeStartProtectedPasswordEntryRequest(
+    const GURL& main_frame_url,
+    const std::string& legitimate_domain) {
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
+  if (!IsPingingEnabled(kProtectedPasswordEntryPinging))
+    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(), legitimate_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 232 matching lines @@
   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;
 }
 
 }  // namespace safe_browsing