Add suborigin logic to url::Origin

url/origin.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 "url/origin.h"
 
 #include <stdint.h>
 #include <string.h>
 
 #include "base/logging.h"
 #include "base/strings/string_number_conversions.h"
 #include "url/gurl.h"
 #include "url/url_canon.h"
 #include "url/url_canon_stdstring.h"
 #include "url/url_constants.h"
 #include "url/url_util.h"
 
 namespace url {
 
+namespace {
+
+GURL AddSuboriginToUrl(const GURL& url, const std::string& suborigin) {
+  GURL::Replacements replacements;
+  replacements.SetSchemeStr((url.scheme() == kHttpScheme)
+                                ? kHttpSuboriginScheme
+                                : kHttpsSuboriginScheme);
+  std::string new_host = suborigin + "." + url.host();
+  replacements.SetHostStr(new_host);
+  return url.ReplaceComponents(replacements);
+}
+
+}  // namespace
+
 Origin::Origin() : unique_(true) {
 }
 
 Origin::Origin(const GURL& url) : unique_(true) {
   if (!url.is_valid() || (!url.IsStandard() && !url.SchemeIsBlob()))
     return;
 
   if (url.SchemeIsFileSystem()) {
     tuple_ = SchemeHostPort(*url.inner_url());
   } else if (url.SchemeIsBlob()) {
     // If we're dealing with a 'blob:' URL, https://url.spec.whatwg.org/#origin
     // defines the origin as the origin of the URL which results from parsing
     // the "path", which boils down to everything after the scheme. GURL's
     // 'GetContent()' gives us exactly that.
     tuple_ = SchemeHostPort(GURL(url.GetContent()));
+  } else if (url.SchemeIsSuborigin()) {
+    GURL::Replacements replacements;
+    if (url.scheme() == kHttpSuboriginScheme) {
+      replacements.SetSchemeStr(kHttpScheme);
+    } else {
+      DCHECK(url.scheme() == kHttpsSuboriginScheme);
+      replacements.SetSchemeStr(kHttpsScheme);
+    }

[nasko, 2016/10/13 22:16:45]

Why not keep the same code in AddSuboriginToUrl? There you use the tertiary
operator and no DCHECK, here you have if statement and DCHECK. I like DCHECKs in
general :).

[jww, 2016/10/14 01:08:58]

Done.

+
+    std::string host = url.host();
+    size_t suborigin_end = host.find(".");
+    bool no_dot = suborigin_end == std::string::npos;
+    std::string new_host(
+        no_dot ? ""
+               : host.substr(suborigin_end + 1,
+                             url.host().length() - suborigin_end - 1));
+    replacements.SetHostStr(new_host);
+
+    tuple_ = SchemeHostPort(url.ReplaceComponents(replacements));
+
+    bool invalid_suborigin = no_dot || suborigin_end == 0;
+    if (invalid_suborigin || tuple_.IsInvalid()) {
+      suborigin_ = "";

[nasko, 2016/10/13 22:16:45]

Why not add this to the initializer list? That way, you can just return straight
away and you will get the default unique_ = true and empty string for
suborigin_.

[jww, 2016/10/14 01:08:58]

Done.

+      unique_ = true;
+      return;
+    }
+
+    suborigin_ = host.substr(0, suborigin_end);
   } else {
     tuple_ = SchemeHostPort(url);
   }
 
   unique_ = tuple_.IsInvalid();
 }
 
 Origin::Origin(base::StringPiece scheme, base::StringPiece host, uint16_t port)
     : tuple_(scheme, host, port) {
   unique_ = tuple_.IsInvalid();
@@ skipping 10 matching lines @@
   return Origin(scheme, host, port);
 }
 
 std::string Origin::Serialize() const {
   if (unique())
     return "null";
 
   if (scheme() == kFileScheme)
     return "file://";
 
+  if (!suborigin_.empty()) {
+    GURL url_with_suborigin = AddSuboriginToUrl(tuple_.GetURL(), suborigin_);
+    return SchemeHostPort(url_with_suborigin).Serialize();
+  }
+
   return tuple_.Serialize();
 }
 
+std::string Origin::SerializePhysicalOrigin() const {
+  if (unique())
+    return "null";
+
+  if (scheme() == kFileScheme)
+    return "file://";
+
+  // Note that there is no special case for suborigins because the
+  // SchemeHostPort |tuple_| explicitly represents the components of the
+  // physical origin, so that alone is what is needed to serialize for the
+  // suborigin.
+  return tuple_.Serialize();

[nasko, 2016/10/13 22:16:45]

This part of the comment is a bit confusing "so that alone is what is needed to
serialize for the suborigin". Did you mean something like "so that alone is what
is needed to serialize without the suborigin"?

[jww, 2016/10/14 01:08:58]

Yes, that's what I meant. I tried to clarify the comment; let me know if it's no
good.

+}
+
 GURL Origin::GetURL() const {
   if (unique())
     return GURL();
 
   if (scheme() == kFileScheme)
     return GURL("file:///");
 
-  return tuple_.GetURL();
+  GURL tuple_url(tuple_.GetURL());
+
+  if (!suborigin_.empty())
+    return AddSuboriginToUrl(tuple_url, suborigin_);
+
+  return tuple_url;
 }
 
 bool Origin::IsSameOriginWith(const Origin& other) const {
+  return IsSamePhysicalOriginWith(other) && suborigin_ == other.suborigin_;
+}
+
+bool Origin::IsSamePhysicalOriginWith(const Origin& other) const {
   if (unique_ || other.unique_)
     return false;
 
   return tuple_.Equals(other.tuple_);
 }
 
 bool Origin::DomainIs(base::StringPiece lower_ascii_domain) const {
   return !unique_ && url::DomainIs(tuple_.host(), lower_ascii_domain);
 }
 
 bool Origin::operator<(const Origin& other) const {
   return tuple_ < other.tuple_;
 }
 
 std::ostream& operator<<(std::ostream& out, const url::Origin& origin) {
   return out << origin.Serialize();
 }
 
 bool IsSameOriginWith(const GURL& a, const GURL& b) {
   return Origin(a).IsSameOriginWith(Origin(b));
 }
 
+bool IsSamePhysicalOriginWith(const GURL& a, const GURL& b) {
+  return Origin(a).IsSamePhysicalOriginWith(Origin(b));
+}
+
 }  // namespace url