Switch to static_assert.

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 219 matching lines @@
     if (!domain_to_registry_controlled_domain.count(domain)) {
       domain_to_registry_controlled_domain[domain] =
           GetRegistryControlledDomain(signon_realm_url);
       if (domain_to_registry_controlled_domain[domain].empty())
         domain_to_registry_controlled_domain[domain] = domain;
     }
     const std::string& registry_controlled_domain =
         domain_to_registry_controlled_domain[domain];
 
     Scheme scheme = SCHEME_HTTP;
-    COMPILE_ASSERT(arraysize(kAllSchemes) == 2, "Update this logic");
+    static_assert(arraysize(kAllSchemes) == 2, "Update this logic");
     if (signon_realm_url.SchemeIs(url::kHttpsScheme))
       scheme = SCHEME_HTTPS;
     else if (!signon_realm_url.SchemeIs(url::kHttpScheme))
       continue;
 
     statistics[scheme].num_accounts_per_domain[domain]++;
     statistics[scheme].num_accounts_per_registry_controlled_domain
         [registry_controlled_domain]++;
     statistics[scheme].num_total_accounts++;
   }
 
   // For each "source" account of either scheme, count the number of "target"
   // accounts reusing the same password (of either scheme).
   for (const Scheme scheme : kAllSchemes) {
     for (const auto& kv : statistics[scheme].num_accounts_per_domain) {
       const std::string& domain(kv.first);
       const int num_accounts_per_domain(kv.second);
       const std::string& registry_controlled_domain =
           domain_to_registry_controlled_domain[domain];
 
       Scheme other_scheme = scheme == SCHEME_HTTP ? SCHEME_HTTPS : SCHEME_HTTP;
-      COMPILE_ASSERT(arraysize(kAllSchemes) == 2, "Update |other_scheme|");
+      static_assert(arraysize(kAllSchemes) == 2, "Update |other_scheme|");
 
       // Discount the account at hand from the number of accounts with the same
       // domain and scheme.
       int num_accounts_for_same_domain[arraysize(kAllSchemes)] = {};
       num_accounts_for_same_domain[scheme] =
           statistics[scheme].num_accounts_per_domain[domain] - 1;
       num_accounts_for_same_domain[other_scheme] =
           statistics[other_scheme].num_accounts_per_domain[domain];
 
       // By definition, a PSL match requires the scheme to be the same.
       int num_psl_matching_accounts =
           statistics[scheme].num_accounts_per_registry_controlled_domain
               [registry_controlled_domain] -
           statistics[scheme].num_accounts_per_domain[domain];
 
       // Discount PSL matches from the number of accounts with different domains
       // but the same scheme.
       int num_accounts_for_different_domain[arraysize(kAllSchemes)] = {};
       num_accounts_for_different_domain[scheme] =
           statistics[scheme].num_total_accounts -
           statistics[scheme].num_accounts_per_registry_controlled_domain
               [registry_controlled_domain];
       num_accounts_for_different_domain[other_scheme] =
           statistics[other_scheme].num_total_accounts -
           statistics[other_scheme].num_accounts_per_domain[domain];
 
       std::string source_realm_kind =
           scheme == SCHEME_HTTP ? "FromHttpRealm" : "FromHttpsRealm";
-      COMPILE_ASSERT(arraysize(kAllSchemes) == 2, "Update |source_realm_kind|");
+      static_assert(arraysize(kAllSchemes) == 2, "Update |source_realm_kind|");
 
       // So far, the calculation has been carried out once per "source" domain,
       // but the metrics need to be recorded on a per-account basis. The set of
       // metrics are the same for all accounts for the same domain, so simply
       // report them as many times as accounts.
       for (int i = 0; i < num_accounts_per_domain; ++i) {
         LogNumberOfAccountsReusingPassword(
             source_realm_kind + ".OnHttpRealmWithSameHost",
             num_accounts_for_same_domain[SCHEME_HTTP], HistogramSize::SMALL);
         LogNumberOfAccountsReusingPassword(
@@ skipping 987 matching lines @@
     UMA_HISTOGRAM_ENUMERATION("PasswordManager.PslDomainMatchTriggering",
                               psl_domain_match_metric, PSL_DOMAIN_MATCH_COUNT);
   }
 
   if (!statement->Succeeded())
     return false;
   return true;
 }
 
 }  // namespace password_manager