SameSite: Strict/Lax behavior.

net/base/registry_controlled_domains/registry_controlled_domain.h

 // Copyright (c) 2012 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.
 
 // NB: Modelled after Mozilla's code (originally written by Pamela Greene,
 // later modified by others), but almost entirely rewritten for Chrome.
 //   (netwerk/dns/src/nsEffectiveTLDService.h)
 /* ***** BEGIN LICENSE BLOCK *****
  * Version: MPL 1.1/GPL 2.0/LGPL 2.1
  *
@@ skipping 104 matching lines @@
 
 #include <stddef.h>
 
 #include <string>
 
 #include "base/strings/string_piece.h"
 #include "net/base/net_export.h"
 
 class GURL;
 
+namespace url {
+class Origin;
+};
+
 struct DomainRule;
 
 namespace net {
 namespace registry_controlled_domains {
 
 // This enum is a required parameter to all public methods declared for this
 // service. The Public Suffix List (http://publicsuffix.org/) this service
 // uses as a data source splits all effective-TLDs into two groups. The main
 // group describes registries that are acknowledged by ICANN. The second group
 // contains a list of private additions for domains that enable external users
@@ skipping 41 matching lines @@
 //   http://co.uk/file.html          -> ""            (host is a registry)
 //   http://foo.bar/file.html        -> "foo.bar"     (no rule; assume bar)
 NET_EXPORT std::string GetDomainAndRegistry(const GURL& gurl,
                                             PrivateRegistryFilter filter);
 
 // Like the GURL version, but takes a host (which is canonicalized internally)
 // instead of a full GURL.
 NET_EXPORT std::string GetDomainAndRegistry(base::StringPiece host,
                                             PrivateRegistryFilter filter);
 
-// This convenience function returns true if the two GURLs both have hosts
-// and one of the following is true:
+// These convenience functions return true if the two GURLs or Origins both have
+// hosts and one of the following is true:
 // * They each have a known domain and registry, and it is the same for both
 //   URLs.  Note that this means the trailing dot, if any, must match too.
 // * They don't have known domains/registries, but the hosts are identical.
 // Effectively, callers can use this function to check whether the input URLs
 // represent hosts "on the same site".
 NET_EXPORT bool SameDomainOrHost(const GURL& gurl1, const GURL& gurl2,
                                  PrivateRegistryFilter filter);
+NET_EXPORT bool SameDomainOrHost(const url::Origin& origin1,
+                                 const url::Origin& origin2,
+                                 PrivateRegistryFilter filter);
 
 // Finds the length in bytes of the registrar portion of the host in the
 // given GURL.  Returns std::string::npos if the GURL is invalid or has no
 // host (e.g. a file: URL).  Returns 0 if the GURL has multiple trailing dots,
 // is an IP address, has no subcomponents, or is itself a recognized registry
 // identifier.  The result is also dependent on the UnknownRegistryFilter.
 // If no matching rule is found in the effective-TLD data (or in
 // the default data, if the resource failed to load), returns 0 if
 // |unknown_filter| is EXCLUDE_UNKNOWN_REGISTRIES, or the length of the last
 // subcomponent if |unknown_filter| is INCLUDE_UNKNOWN_REGISTRIES.
@@ skipping 26 matching lines @@
 // Used for unit tests. Use default domains.
 NET_EXPORT_PRIVATE void SetFindDomainGraph();
 
 // Used for unit tests, so that a frozen list of domains is used.
 NET_EXPORT_PRIVATE void SetFindDomainGraph(const unsigned char* domains,
                                            size_t length);
 }  // namespace registry_controlled_domains
 }  // namespace net
 
 #endif  // NET_BASE_REGISTRY_CONTROLLED_DOMAINS_REGISTRY_CONTROLLED_DOMAIN_H_