Add url::Origin::GetURL() to convert Origins to URLs without reparsing

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 {
+
+const char kRootFileUrl[] = "file:///";
+
+}  // 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()) {
@@ skipping 23 matching lines @@
     base::StringPiece host,
     uint16_t port) {
   return Origin(scheme, host, port);
 }
 
 std::string Origin::Serialize() const {
   if (unique())
     return "null";
 
   if (scheme() == kFileScheme)
-    return "file://";
+    return kRootFileUrl;

[brettw, 2016/10/03 18:56:34]

It looks like this returns the new "file:///" instead which doesn't match what
you said in the last review comment. (If these two cases have to be different,
the constant at the top probably isn't helping).

Assumeing they should be different, it's probably a good idea to call out in
comments here in the implementation why (even though we're adding something to
the header) so somebody doesn't try to "fix" it later.

 
   return tuple_.Serialize();
 }
 
+GURL Origin::GetURL() const {
+  if (unique())
+    return GURL();
+
+  if (scheme() == kFileScheme)
+    return GURL(kRootFileUrl);
+
+  return tuple_.GetURL();
+}
+
 bool Origin::IsSameOriginWith(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));
 }
 
 }  // namespace url