Re-enable storage for Suborigins.

content/common/origin_util.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 "content/public/common/origin_util.h"
 
 #include "base/lazy_instance.h"
 #include "base/macros.h"
 #include "base/stl_util.h"
 #include "content/public/common/content_client.h"
+#include "content/public/common/url_constants.h"
 #include "net/base/url_util.h"
 #include "url/gurl.h"
+#include "url/url_constants.h"
 
 namespace content {
 
 namespace {
 
 class SchemeAndOriginWhitelist {
  public:
   SchemeAndOriginWhitelist() { Reset(); }
   ~SchemeAndOriginWhitelist() {}
 
@@ skipping 60 matching lines @@
     return true;
   }
 
   return false;
 }
 
 void ResetSchemesAndOriginsWhitelistForTesting() {
   g_trustworthy_whitelist.Get().Reset();
 }
 
+bool HasSuborigin(const GURL& url) {
+  if (!url.is_valid())
+    return false;
+
+  if (url.scheme() != kHttpSuboriginScheme &&
+      url.scheme() != kHttpsSuboriginScheme) {
+    return false;
+  }
+
+  std::string host = url.host();

[nasko, 2016/09/29 16:49:55]

minor nit: I don't know how perf sensitive this call will be, but in general we
could probably save making a copy of the host portion by using StringPiece.

[jww, 2016/09/29 22:21:00]

Done.

+
+  // This means that there is no suborigin before the dot, so there is no

[nasko, 2016/09/29 16:49:56]

Technically it means there is no dot at all : ).

[jww, 2016/09/29 22:21:00]

I don't understand. Are you referring to the fact that . is ignored in hostnames
if it's the first character? That's true for hostnames, but the suborigin spec
is pretty clear that this isn't possible in a suborigin serialization, unless
you were to have an empty-string suborigin, but that's disallowed separately.
So, basically, since we already know the scheme is a suborigin scheme at this
point, we can safely say that the "hostname" (which is really a serialization of
the suborigin + hostname) shouldn't start with a period.

By way of example, this is for the case (which I have in the unit test) of:
https-so://.foo.com

Here it's the empty string before the first period, which is an invalid
suborigin.

Ah, but I am missing the case where there is no period at all, so I'll add that.

[nasko, 2016/09/30 17:40:07]

I read the code with the interpretation that it is looking for no dot. Thanks
for the info on the extra case you are checking for!

+  // suborigin.
+  if (host.find('.') == 0)

[nasko, 2016/09/29 16:49:56]

s/0/string::npos/?

[jww, 2016/09/29 22:21:00]

See above response. I did intend for this to check if the first character of the
hostname is a period, but perhaps I'm misunderstanding your comment.

+    return false;
+
+  // If there's nothing after the first dot, then there is no host for the
+  // physical origin, which is not a valid suborigin serialization.
+  if (host.find('.') == (host.size() - 1))

[nasko, 2016/09/29 16:49:56]

You could store the result of find from above and reuse it, avoiding doing the
string traversal twice.

[jww, 2016/09/29 22:21:00]

Done.

+    return false;
+
+  return true;
+}
+
+std::string SuboriginFromUrl(const GURL& url) {
+  if (!HasSuborigin(url))
+    return "";
+
+  size_t suborigin_end = url.host().find(".");
+  return url.host().substr(0, suborigin_end);

[nasko, 2016/09/29 16:49:56]

Check suborigin_end for equality of string::npos and avoid calling substr if
equal. 

[jww, 2016/09/29 22:21:00]

Done.

+}
+
+GURL StripSuboriginFromUrl(const GURL& url) {
+  if (!HasSuborigin(url))
+    return url;
+
+  GURL::Replacements replacements;
+  if (url.scheme() == kHttpSuboriginScheme) {
+    replacements.SetSchemeStr(url::kHttpScheme);
+  } else {
+    DCHECK(url.scheme() == kHttpsSuboriginScheme);
+    replacements.SetSchemeStr(url::kHttpsScheme);
+  }
+
+  size_t suborigin_end = url.host().find(".");

[nasko, 2016/09/29 16:49:56]

Again, check for string::npos.

[jww, 2016/09/29 22:21:00]

Done.

+  std::string new_host(url.host().substr(
+      suborigin_end + 1, url.host().length() - suborigin_end - 1));
+  replacements.SetHostStr(new_host);
+
+  return url.ReplaceComponents(replacements);
+}
+
 }  // namespace content