Fetch federated PSL-matches from the password store.

components/password_manager/core/browser/login_database.cc

 // Copyright 2014 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/password_manager/core/browser/login_database.h"
 
 #include <stddef.h>
 #include <stdint.h>
 #include <algorithm>
 #include <limits>
@@ skipping 1069 matching lines @@
     base::ReplaceChars(scheme, ".", "\\.", &scheme);
     const std::string port = signon_realm.port();
     // For a signon realm such as http://foo.bar/, this regexp will match
     // domains on the form http://foo.bar/, http://www.foo.bar/,
     // http://www.mobile.foo.bar/. It will not match http://notfoo.bar/.
     // The scheme and port has to be the same as the observed form.
     std::string regexp = "^(" + scheme + ":\\/\\/)([\\w-]+\\.)*" +
                          registered_domain + "(:" + port + ")?\\/$";
     s.BindString(placeholder++, regexp);
   }
-  if (should_federated_apply) {
+
+  if (should_PSL_matching_apply && should_federated_apply) {
+    // This regex matches any subdomain of registered_domain, in particular it
+    // matches the empty subdomain. Hence exact domain matches are also

[vasilii, 2017/01/17 16:05:05]

Optionally: move the code into the previous if (should_PSL_matching_apply). Then
there is no need to clarify |registered_domain| escaping.

+    // retrieved.
+    // Periods in registered_domain were already escaped in the previous block.
+    // Therefore they do not need to be escaped again.
+    s.BindString(placeholder++,
+                 "^federation://([\\w-]+\\.)*" + registered_domain + "/.+$");
+  } else if (should_federated_apply) {
     std::string expression =
         base::StringPrintf("federation://%s/%%", form.origin.host().c_str());
     s.BindString(placeholder++, expression);
   }
 
   if (!should_PSL_matching_apply && !should_federated_apply) {
     // Otherwise the histogram is reported in StatementToForms.
     UMA_HISTOGRAM_ENUMERATION("PasswordManager.PslDomainMatchTriggering",
                               PSL_DOMAIN_MATCH_NOT_USED,
                               PSL_DOMAIN_MATCH_COUNT);
@@ skipping 113 matching lines @@
       if (new_form->scheme != PasswordForm::SCHEME_HTML)
         continue;  // Ignore non-HTML matches.
 
       if (IsPublicSuffixDomainMatch(new_form->signon_realm,
                                     matched_form->signon_realm)) {
         psl_domain_match_metric = PSL_DOMAIN_MATCH_FOUND;
         new_form->is_public_suffix_match = true;
       } else if (!new_form->federation_origin.unique() &&
                  IsFederatedMatch(new_form->signon_realm,
                                   matched_form->origin)) {
+      } else if (!new_form->federation_origin.unique() &&
+                 IsFederatedPSLMatch(new_form->signon_realm,
+                                     matched_form->origin)) {
+        psl_domain_match_metric = PSL_DOMAIN_MATCH_FOUND_FEDERATED;
+        new_form->is_public_suffix_match = true;
       } else {
         continue;
       }
     }
     forms->push_back(std::move(new_form));
   }
 
   if (matched_form) {
     UMA_HISTOGRAM_ENUMERATION("PasswordManager.PslDomainMatchTriggering",
                               psl_domain_match_metric, PSL_DOMAIN_MATCH_COUNT);
@@ skipping 36 matching lines @@
   autosignin_statement_ = "SELECT " + all_column_names +
                           " FROM logins "
                           "WHERE skip_zero_click = 0 ORDER BY origin_url";
   DCHECK(get_statement_.empty());
   get_statement_ = "SELECT " + all_column_names +
                    " FROM logins "
                    "WHERE signon_realm == ?";
   std::string psl_statement = "OR signon_realm REGEXP ? ";
   std::string federated_statement =
       "OR (signon_realm LIKE ? AND password_type == 2) ";
+  std::string psl_federated_statement =
+      "OR (signon_realm REGEXP ? AND password_type == 2) ";
   DCHECK(get_statement_psl_.empty());
   get_statement_psl_ = get_statement_ + psl_statement;
   DCHECK(get_statement_federated_.empty());
   get_statement_federated_ = get_statement_ + federated_statement;
   DCHECK(get_statement_psl_federated_.empty());
   get_statement_psl_federated_ =
-      get_statement_ + psl_statement + federated_statement;
+      get_statement_ + psl_statement + psl_federated_statement;
   DCHECK(created_statement_.empty());
   created_statement_ =
       "SELECT " + all_column_names +
       " FROM logins WHERE date_created >= ? AND date_created < "
       "? ORDER BY origin_url";
   DCHECK(synced_statement_.empty());
   synced_statement_ = "SELECT " + all_column_names +
                       " FROM logins WHERE date_synced >= ? AND date_synced < "
                       "? ORDER BY origin_url";
   DCHECK(blacklisted_statement_.empty());
   blacklisted_statement_ =
       "SELECT " + all_column_names +
       " FROM logins WHERE blacklisted_by_user == ? ORDER BY origin_url";
   DCHECK(encrypted_statement_.empty());
   encrypted_statement_ =
       "SELECT password_value FROM logins WHERE " + all_unique_key_column_names;
 }
 
 }  // namespace password_manager