Remove Finch kill switch for PSL matching

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 <algorithm>
 #include <limits>
 
 #include "base/bind.h"
@@ skipping 559 matching lines @@
   // You *must* change LoginTableColumns if this query changes.
   const std::string sql_query = "SELECT origin_url, action_url, "
       "username_element, username_value, "
       "password_element, password_value, submit_element, "
       "signon_realm, ssl_valid, preferred, date_created, blacklisted_by_user, "
       "scheme, password_type, possible_usernames, times_used, form_data, "
       "use_additional_auth, date_synced, display_name, avatar_url, "
       "federation_url, is_zero_click FROM logins WHERE signon_realm == ? ";
   sql::Statement s;
   const GURL signon_realm(form.signon_realm);
-  std::string registered_domain =
-      PSLMatchingHelper::GetRegistryControlledDomain(signon_realm);
-  PSLMatchingHelper::PSLDomainMatchMetric psl_domain_match_metric =
-      PSLMatchingHelper::PSL_DOMAIN_MATCH_NONE;
+  std::string registered_domain = GetRegistryControlledDomain(signon_realm);
+  PSLDomainMatchMetric psl_domain_match_metric = PSL_DOMAIN_MATCH_NONE;
+  const bool should_PSL_matching_apply =
+      ShouldPSLDomainMatchingApply(registered_domain);
   // PSL matching only applies to HTML forms.
-  if (form.scheme == PasswordForm::SCHEME_HTML &&
-      psl_helper_.ShouldPSLDomainMatchingApply(registered_domain)) {
+  if (form.scheme == PasswordForm::SCHEME_HTML && should_PSL_matching_apply) {
     // We are extending the original SQL query with one that includes more
     // possible matches based on public suffix domain matching. Using a regexp
     // here is just an optimization to not have to parse all the stored entries
     // in the |logins| table. The result (scheme, domain and port) is verified
     // further down using GURL. See the functions SchemeMatches,
     // RegistryControlledDomainMatches and PortMatches.
     const std::string extended_sql_query =
         sql_query + "OR signon_realm REGEXP ? ";
     // TODO(nyquist) Re-enable usage of GetCachedStatement when
     // http://crbug.com/248608 is fixed.
     s.Assign(db_.GetUniqueStatement(extended_sql_query.c_str()));
     // We need to escape . in the domain. Since the domain has already been
     // sanitized using GURL, we do not need to escape any other characters.
     base::ReplaceChars(registered_domain, ".", "\\.", &registered_domain);
     std::string scheme = signon_realm.scheme();
     // We need to escape . in the scheme. Since the scheme has already been
     // sanitized using GURL, we do not need to escape any other characters.
     // The scheme soap.beep is an example with '.'.
     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(0, form.signon_realm);
     s.BindString(1, regexp);
   } else {
-    psl_domain_match_metric = PSLMatchingHelper::PSL_DOMAIN_MATCH_DISABLED;
+    psl_domain_match_metric = PSL_DOMAIN_MATCH_NOT_USED;
     s.Assign(db_.GetCachedStatement(SQL_FROM_HERE, sql_query.c_str()));
     s.BindString(0, form.signon_realm);
   }
 
   while (s.Step()) {
     scoped_ptr<PasswordForm> new_form(new PasswordForm());
     EncryptionResult result = InitPasswordFormFromStatement(new_form.get(), s);
     if (result == ENCRYPTION_RESULT_SERVICE_FAILURE)
       return false;
     if (result == ENCRYPTION_RESULT_ITEM_FAILURE)
       continue;
     DCHECK(result == ENCRYPTION_RESULT_SUCCESS);
-    if (psl_helper_.IsMatchingEnabled()) {
-      if (!PSLMatchingHelper::IsPublicSuffixDomainMatch(new_form->signon_realm,
-                                                        form.signon_realm)) {
+    if (should_PSL_matching_apply) {
+      if (!IsPublicSuffixDomainMatch(new_form->signon_realm,
+                                     form.signon_realm)) {
         // The database returned results that should not match. Skipping result.
         continue;
       }
       if (form.signon_realm != new_form->signon_realm) {
         // Ignore non-HTML matches.
         if (new_form->scheme != PasswordForm::SCHEME_HTML)
           continue;
 
-        psl_domain_match_metric = PSLMatchingHelper::PSL_DOMAIN_MATCH_FOUND;
+        psl_domain_match_metric = PSL_DOMAIN_MATCH_FOUND;
         // This is not a perfect match, so we need to create a new valid result.
         // We do this by copying over origin, signon realm and action from the
         // observed form and setting the original signon realm to what we found
         // in the database. We use the fact that |original_signon_realm| is
         // non-empty to communicate that this match was found using public
         // suffix matching.
         new_form->original_signon_realm = new_form->signon_realm;
         new_form->origin = form.origin;
         new_form->signon_realm = form.signon_realm;
         new_form->action = form.action;
       }
     }
     forms->push_back(new_form.release());
   }
   UMA_HISTOGRAM_ENUMERATION("PasswordManager.PslDomainMatchTriggering",
                             psl_domain_match_metric,
-                            PSLMatchingHelper::PSL_DOMAIN_MATCH_COUNT);
+                            PSL_DOMAIN_MATCH_COUNT);
   return s.Succeeded();
 }
 
 bool LoginDatabase::GetLoginsCreatedBetween(
     const base::Time begin,
     const base::Time end,
     std::vector<autofill::PasswordForm*>* forms) const {
   DCHECK(forms);
   sql::Statement s(db_.GetCachedStatement(SQL_FROM_HERE,
       "SELECT origin_url, action_url, "
@@ skipping 95 matching lines @@
 
 bool LoginDatabase::DeleteAndRecreateDatabaseFile() {
   DCHECK(db_.is_open());
   meta_table_.Reset();
   db_.Close();
   sql::Connection::Delete(db_path_);
   return Init(db_path_);
 }
 
 }  // namespace password_manager