Implement Federated PSL Matches in Native Backends

chrome/browser/password_manager/native_backend_libsecret.cc

 // Copyright (c) 2015 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_libsecret.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <libsecret/secret.h>
 
 #include <limits>
 #include <list>
 #include <memory>
 #include <utility>
 #include <vector>
 
 #include "base/logging.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "components/password_manager/core/browser/password_manager_metrics_util.h"
 #include "components/password_manager/core/browser/password_manager_util.h"
 #include "url/origin.h"
 
 using autofill::PasswordForm;
 using base::UTF8ToUTF16;
 using base::UTF16ToUTF8;
+using password_manager::MatchResult;
 using password_manager::PasswordStore;
 
 namespace {
 const char kEmptyString[] = "";
 const int kMaxPossibleTimeTValue = std::numeric_limits<int>::max();
 }  // namespace
 
 namespace {
 
 const char kLibsecretAppString[] = "chrome";
@@ skipping 469 matching lines @@
 }
 
 std::vector<std::unique_ptr<PasswordForm>>
 NativeBackendLibsecret::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;
   GError* error = nullptr;
-  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 != nullptr;
        element = g_list_next(element)) {
     SecretItem* secretItem = static_cast<SecretItem*>(element->data);
     LibsecretLoader::secret_item_load_secret_sync(secretItem, nullptr, &error);
     if (error) {
       LOG(ERROR) << "Unable to load secret item" << error->message;
       g_error_free(error);
       error = nullptr;
       continue;
     }
     GHashTable* attrs = LibsecretLoader::secret_item_get_attributes(secretItem);
     std::unique_ptr<PasswordForm> form(FormOutOfAttributes(attrs));
     g_hash_table_unref(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)
+    if (!form) {
+      VLOG(1) << "Could not initialize PasswordForm from attributes!";
+      continue;
+    }
+
+    if (lookup_form) {
+      switch (GetMatchResult(*form, *lookup_form)) {
+        case MatchResult::NO_MATCH:
           continue;
-        // 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)) {
+        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;
       }
-      SecretValue* secretValue =
-          LibsecretLoader::secret_item_get_secret(secretItem);
-      if (secretValue) {
-        form->password_value =
-            UTF8ToUTF16(LibsecretLoader::secret_value_get_text(secretValue));
-        LibsecretLoader::secret_value_unref(secretValue);
-      } else {
-        LOG(WARNING) << "Unable to access password from list element!";
-      }
-      forms.push_back(std::move(form));
+    }
+
+    SecretValue* secretValue =
+        LibsecretLoader::secret_item_get_secret(secretItem);
+    if (secretValue) {
+      form->password_value =
+          UTF8ToUTF16(LibsecretLoader::secret_value_get_text(secretValue));
+      LibsecretLoader::secret_value_unref(secretValue);
     } else {
-      VLOG(1) << "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);
   }
   g_list_free(found);
   return forms;
 }