Implement SDCH Dictionary domain matching as per RFC 2965

net/base/sdch_dictionary.cc

 // Copyright 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 "net/base/sdch_dictionary.h"
 
+#include "base/strings/string_util.h"
 #include "base/time/clock.h"
 #include "base/time/default_clock.h"
 #include "base/values.h"
 #include "net/base/registry_controlled_domains/registry_controlled_domain.h"
-
-namespace {
-
-bool DomainMatch(const GURL& gurl, const std::string& restriction) {
-  // TODO(jar): This is not precisely a domain match definition.
-  return gurl.DomainIs(restriction);
-}
-
-}  // namespace
+#include "net/base/url_util.h"
 
 namespace net {
 
 SdchDictionary::SdchDictionary(const std::string& dictionary_text,
                                size_t offset,
                                const std::string& client_hash,
                                const std::string& server_hash,
                                const GURL& gurl,
                                const std::string& domain,
                                const std::string& path,
@@ skipping 50 matching lines @@
 
   if (domain.empty())
     return SDCH_DICTIONARY_MISSING_DOMAIN_SPECIFIER;  // Domain is required.
 
   if (registry_controlled_domains::GetDomainAndRegistry(
           domain, registry_controlled_domains::INCLUDE_PRIVATE_REGISTRIES)
           .empty()) {
     return SDCH_DICTIONARY_SPECIFIES_TOP_LEVEL_DOMAIN;  // domain was a TLD.
   }
 
-  if (!DomainMatch(dictionary_url, domain))
+  if (!IsDomainMatch(domain, dictionary_url.host()))
     return SDCH_DICTIONARY_DOMAIN_NOT_MATCHING_SOURCE_URL;
 
   std::string referrer_url_host = dictionary_url.host();
   size_t postfix_domain_index = referrer_url_host.rfind(domain);
   // See if it is indeed a postfix, or just an internal string.
   if (referrer_url_host.size() == postfix_domain_index + domain.size()) {
     // It is a postfix... so check to see if there's a dot in the prefix.
     size_t end_of_host_index = referrer_url_host.find_first_of('.');
     if (referrer_url_host.npos != end_of_host_index &&
         end_of_host_index < postfix_domain_index) {
@@ skipping 11 matching lines @@
   /*
    * 1. The request URL's host name domain-matches the Domain attribute of the
    *    dictionary.
    * 2. If the dictionary has a Port attribute, the request port is one of the
    *     ports listed in the Port attribute.
    * 3. The request URL path-matches the path attribute of the dictionary.
    *    We can override (ignore) item (4) only when we have explicitly enabled
    *    HTTPS support AND the dictionary acquisition scheme matches the target
    *   url scheme.
    */
-  if (!DomainMatch(target_url, domain_))
+  if (!IsDomainMatch(domain_, target_url.host()))
     return SDCH_DICTIONARY_FOUND_HAS_WRONG_DOMAIN;
 
   if (!ports_.empty() && 0 == ports_.count(target_url.EffectiveIntPort()))
     return SDCH_DICTIONARY_FOUND_HAS_WRONG_PORT_LIST;
 
   if (path_.size() && !PathMatch(target_url.path(), path_))
     return SDCH_DICTIONARY_FOUND_HAS_WRONG_PATH;
 
   if (target_url.SchemeIsCryptographic() != url_.SchemeIsCryptographic())
     return SDCH_DICTIONARY_FOUND_HAS_WRONG_SCHEME;
@@ skipping 22 matching lines @@
   if (0 != path.compare(0, prefix_length, restriction))
     return false;
   return restriction[prefix_length - 1] == '/' || path[prefix_length] == '/';
 }
 
 bool SdchDictionary::Expired() const {
   return base::Time::Now() > expiration_;
 }
 
 }  // namespace net