Implement Federated PSL Matches in Native Backends

chrome/browser/password_manager/native_backend_gnome_x.cc

 // Copyright (c) 2012 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 "chrome/browser/password_manager/native_backend_gnome_x.h"
 
 #include <limits>
 #include <map>
 #include <memory>
 #include <string>
@@ skipping 13 matching lines @@
 #include "components/password_manager/core/browser/password_manager_metrics_util.h"
 #include "components/password_manager/core/browser/password_manager_util.h"
 #include "components/password_manager/core/browser/psl_matching_helper.h"
 #include "content/public/browser/browser_thread.h"
 
 using autofill::PasswordForm;
 using base::UTF8ToUTF16;
 using base::UTF16ToUTF8;
 using content::BrowserThread;
 using namespace password_manager::metrics_util;
+using password_manager::MatchResult;
 using password_manager::PasswordStore;
 
 namespace {
 const int kMaxPossibleTimeTValue = std::numeric_limits<int>::max();
 }
 
 namespace {
 
 const char kGnomeKeyringAppString[] = "chrome";
 
@@ skipping 70 matching lines @@
 // realms passing the PSL matching against |lookup_form->signon_realm| will be
 // kept. PSL matched results get their signon_realm, origin, and action
 // rewritten to those of |lookup_form_|, with the original signon_realm saved
 // into the result's original_signon_realm data member.
 std::vector<std::unique_ptr<PasswordForm>> ConvertFormList(
     GList* found,
     const PasswordStore::FormDigest* lookup_form) {
   std::vector<std::unique_ptr<PasswordForm>> forms;
   password_manager::PSLDomainMatchMetric psl_domain_match_metric =
       password_manager::PSL_DOMAIN_MATCH_NONE;
-  const bool allow_psl_match =
-      lookup_form && password_manager::ShouldPSLDomainMatchingApply(
-                         password_manager::GetRegistryControlledDomain(
-                             GURL(lookup_form->signon_realm)));
   for (GList* element = g_list_first(found); element;
        element = g_list_next(element)) {
     GnomeKeyringFound* data = static_cast<GnomeKeyringFound*>(element->data);
     GnomeKeyringAttributeList* attrs = data->attributes;
 
     std::unique_ptr<PasswordForm> form(FormFromAttributes(attrs));
-    if (form) {
-      if (lookup_form && form->signon_realm != lookup_form->signon_realm) {
-        if (lookup_form->scheme != PasswordForm::SCHEME_HTML ||
-            form->scheme != PasswordForm::SCHEME_HTML)
-          continue;  // Ignore non-HTML matches.
-        // This is not an exact match, we try PSL matching and federated match.
-        if (allow_psl_match &&
-            password_manager::IsPublicSuffixDomainMatch(
-                form->signon_realm, lookup_form->signon_realm)) {
+    if (!form) {
+      LOG(WARNING) << "Could not initialize PasswordForm from attributes!";
+      continue;
+    }
+
+    if (lookup_form) {
+      switch (GetMatchResult(*form, *lookup_form)) {
+        case MatchResult::NO_MATCH:
+          continue;
+        case MatchResult::EXACT_MATCH:
+          break;
+        case MatchResult::PSL_MATCH:
           psl_domain_match_metric = password_manager::PSL_DOMAIN_MATCH_FOUND;
           form->is_public_suffix_match = true;
-        } else if (!form->federation_origin.unique() &&
-                   password_manager::IsFederatedMatch(form->signon_realm,
-                                                      lookup_form->origin)) {
-        } else {
-          continue;
-        }
+          break;
+        case MatchResult::FEDERATED_MATCH:
+          break;
+        case MatchResult::FEDERATED_PSL_MATCH:
+          psl_domain_match_metric =
+              password_manager::PSL_DOMAIN_MATCH_FOUND_FEDERATED;
+          form->is_public_suffix_match = true;
+          break;
       }
-      if (data->secret) {
-        form->password_value = UTF8ToUTF16(data->secret);
-      } else {
-        LOG(WARNING) << "Unable to access password from list element!";
-      }
-      forms.push_back(std::move(form));
+    }
+
+    if (data->secret) {
+      form->password_value = UTF8ToUTF16(data->secret);
     } else {
-      LOG(WARNING) << "Could not initialize PasswordForm from attributes!";
+      LOG(WARNING) << "Unable to access password from list element!";
     }
+    forms.push_back(std::move(form));
   }
   if (lookup_form) {
+    const bool allow_psl_match = password_manager::ShouldPSLDomainMatchingApply(
+        password_manager::GetRegistryControlledDomain(
+            GURL(lookup_form->signon_realm)));
     UMA_HISTOGRAM_ENUMERATION("PasswordManager.PslDomainMatchTriggering",
                               allow_psl_match
                                   ? psl_domain_match_metric
                                   : password_manager::PSL_DOMAIN_MATCH_NOT_USED,
                               password_manager::PSL_DOMAIN_MATCH_COUNT);
   }
   return forms;
 }
 
 // Schema is analogous to the fields in PasswordForm.
@@ skipping 602 matching lines @@
   std::vector<std::unique_ptr<PasswordForm>> forms;
   if (!GetLoginsBetween(get_begin, get_end, date_to_compare, &forms))
     return false;
 
   for (size_t i = 0; i < forms.size(); ++i) {
     if (!RemoveLogin(*forms[i], changes))
       return false;
   }
   return true;
 }