Add Origin::CreateFromNormalizedTuple and call from WebSecurityOrigin

url/scheme_host_port.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/scheme_host_port.h"
 
 #include <stdint.h>
 #include <string.h>
 
 #include <tuple>
@@ skipping 31 matching lines @@
   } else {
     // Empty host, or canonicalization failed.
     canon_host.clear();
   }
 
   return host == canon_host;
 }
 
 bool IsValidInput(const base::StringPiece& scheme,
                   const base::StringPiece& host,
-                  uint16_t port) {
+                  uint16_t port,
+                  SchemeHostPort::ConstructPolicy policy) {
   SchemeType scheme_type = SCHEME_WITH_PORT;
   bool is_standard = GetStandardSchemeType(
       scheme.data(),
       Component(0, base::checked_cast<int>(scheme.length())),
       &scheme_type);
   if (!is_standard)
     return false;
 
   // These schemes do not follow the generic URL syntax, so we treat them as
   // invalid (scheme, host, port) tuples (even though such URLs' _Origin_ might
   // have a (scheme, host, port) tuple, they themselves do not).
   if (scheme == kFileSystemScheme || scheme == kBlobScheme)
     return false;
 
   switch (scheme_type) {
     case SCHEME_WITH_PORT:
       // A URL with |scheme| is required to have the host and port (may be
       // omitted in a serialization if it's the same as the default value).
       // Return an invalid instance if either of them is not given.
       if (host.empty() || port == 0)
         return false;
 
-      if (!IsCanonicalHost(host))
+      // Don't do an expensive canonicalization if the host is already
+      // canonicalized.
+      DCHECK(policy == SchemeHostPort::CHECK_CANONICALIZATION ||
+             IsCanonicalHost(host));
+      if (policy == SchemeHostPort::CHECK_CANONICALIZATION &&
+          !IsCanonicalHost(host)) {
         return false;
+      }
 
       return true;
 
     case SCHEME_WITHOUT_PORT:
       if (port != 0) {
         // Return an invalid object if a URL with the scheme never represents
         // the port data but the given |port| is non-zero.
         return false;
       }
 
-      if (!IsCanonicalHost(host))
+      // Don't do an expensive canonicalization if the host is already
+      // canonicalized.
+      DCHECK(policy == SchemeHostPort::CHECK_CANONICALIZATION ||
+             IsCanonicalHost(host));
+      if (policy == SchemeHostPort::CHECK_CANONICALIZATION &&
+          !IsCanonicalHost(host)) {
         return false;
+      }
 
       return true;
 
     case SCHEME_WITHOUT_AUTHORITY:
       return false;
 
     default:
       NOTREACHED();
       return false;
   }
 }
 
 }  // namespace
 
 SchemeHostPort::SchemeHostPort() : port_(0) {
 }
 
 SchemeHostPort::SchemeHostPort(base::StringPiece scheme,
                                base::StringPiece host,
-                               uint16_t port)
+                               uint16_t port,
+                               ConstructPolicy policy)
     : port_(0) {
-  if (!IsValidInput(scheme, host, port))
+  if (!IsValidInput(scheme, host, port, policy))
     return;
 
   scheme.CopyToString(&scheme_);
   host.CopyToString(&host_);
   port_ = port;
 }
 
+SchemeHostPort::SchemeHostPort(base::StringPiece scheme,
+                               base::StringPiece host,
+                               uint16_t port)
+    : SchemeHostPort(scheme,
+                     host,
+                     port,
+                     ConstructPolicy::CHECK_CANONICALIZATION) {}
+
 SchemeHostPort::SchemeHostPort(const GURL& url) : port_(0) {
   if (!url.is_valid())
     return;
 
   base::StringPiece scheme = url.scheme_piece();
   base::StringPiece host = url.host_piece();
 
   // A valid GURL never returns PORT_INVALID.
   int port = url.EffectiveIntPort();
   if (port == PORT_UNSPECIFIED)
     port = 0;
 
-  if (!IsValidInput(scheme, host, port))
+  if (!IsValidInput(scheme, host, port, ALREADY_CANONICALIZED))
     return;
 
   scheme.CopyToString(&scheme_);
   host.CopyToString(&host_);
   port_ = port;
 }
 
 SchemeHostPort::~SchemeHostPort() {
 }
 
@@ skipping 64 matching lines @@
     result.push_back(':');
     std::string port(base::UintToString(port_));
     parsed->port = Component(result.length(), port.length());
     result.append(std::move(port));
   }
 
   return result;
 }
 
 }  // namespace url