Rename Origin.unique() to opaque().

components/url_pattern_index/url_pattern_index.cc

 // Copyright 2017 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/url_pattern_index/url_pattern_index.h"
 
 #include <algorithm>
 #include <limits>
 #include <string>
 
@@ skipping 423 matching lines @@
   if (domains.size() <= 5) {
     for (auto* domain : domains) {
       const base::StringPiece domain_piece = ToStringPiece(domain);
       if (origin.DomainIs(domain_piece))
         return domain_piece.size();
     }
     return 0;
   }
   // Otherwise look for each subdomain of the |origin| using binary search.
 
-  DCHECK(!origin.unique());
+  DCHECK(!origin.opaque());
   base::StringPiece canonicalized_host(origin.host());
   if (canonicalized_host.empty())
     return 0;
 
   // If the host name ends with a dot, then ignore it.
   if (canonicalized_host.back() == '.')
     canonicalized_host.remove_suffix(1);
 
   // The |left| bound of the search is shared between iterations, because
   // subdomains are considered in decreasing order of their lengths, therefore
@@ skipping 35 matching lines @@
 // considered a "generic" rule. Therefore, if |disable_generic_rules| is set,
 // this function will always return false for such rules.
 bool DoesOriginMatchDomainList(const url::Origin& origin,
                                const flat::UrlRule& rule,
                                bool disable_generic_rules) {
   const bool is_generic = !rule.domains_included();
   DCHECK(is_generic || rule.domains_included()->size());
   if (disable_generic_rules && is_generic)
     return false;
 
-  // Unique |origin| matches lists of exception domains only.
-  if (origin.unique())
+  // Opaque |origin| matches lists of exception domains only.
+  if (origin.opaque())
     return is_generic;
 
   size_t longest_matching_included_domain_length = 1;
   if (!is_generic) {
     longest_matching_included_domain_length =
         GetLongestMatchingSubdomain(origin, *rule.domains_included());
   }
   if (longest_matching_included_domain_length && rule.domains_excluded()) {
     return GetLongestMatchingSubdomain(origin, *rule.domains_excluded()) <
            longest_matching_included_domain_length;
@@ skipping 144 matching lines @@
       (activation_type == flat::ActivationType_NONE)) {
     return nullptr;
   }
 
   return FindMatchInFlatUrlPatternIndex(*flat_index_, url, first_party_origin,
                                         element_type, activation_type,
                                         is_third_party, disable_generic_rules);
 }
 
 }  // namespace url_pattern_index