Add suborigins to WebSecurityOrigin

third_party/WebKit/Source/platform/weborigin/SecurityOrigin.cpp

 /*
  * Copyright (C) 2007 Apple Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  *
  * 1.  Redistributions of source code must retain the above copyright
  *     notice, this list of conditions and the following disclaimer.
  * 2.  Redistributions in binary form must reproduce the above copyright
@@ skipping 111 matching lines @@
       m_effectivePort(url.port() ? url.port()
                                  : defaultPortForProtocol(m_protocol)),
       m_isUnique(false),
       m_universalAccess(false),
       m_domainWasSetInDOM(false),
       m_blockLocalAccessFromLocalOrigin(false),
       m_isUniqueOriginPotentiallyTrustworthy(false) {
   // Suborigins are serialized into the host, so extract it if necessary.
   String suboriginName;
   if (deserializeSuboriginAndProtocolAndHost(m_protocol, m_host, suboriginName,
-                                             m_protocol, m_host))
+                                             m_protocol, m_host)) {
+    if (!url.port())
+      m_effectivePort = defaultPortForProtocol(m_protocol);
+
     m_suborigin.setName(suboriginName);
+  }
 
   // document.domain starts as m_host, but can be set by the DOM.
   m_domain = m_host;
 
   if (isDefaultPortForProtocol(m_port, m_protocol))
     m_port = InvalidPort;
 
   // By default, only local SecurityOrigins can load local resources.
   m_canLoadLocalResources = isLocal();
 }
@@ skipping 311 matching lines @@
 }
 
 // Returns true if and only if a suborigin component was found. If false, no
 // guarantees about the return value |suboriginName| are made.
 bool SecurityOrigin::deserializeSuboriginAndProtocolAndHost(
     const String& oldProtocol,
     const String& oldHost,
     String& suboriginName,
     String& newProtocol,
     String& newHost) {
-  if (!RuntimeEnabledFeatures::suboriginsEnabled())
-    return false;
-
   String originalProtocol = oldProtocol;
   if (oldProtocol != "http-so" && oldProtocol != "https-so")
     return false;
 
   size_t protocolEnd = oldProtocol.reverseFind("-so");
   DCHECK_NE(protocolEnd, WTF::kNotFound);
   newProtocol = oldProtocol.substring(0, protocolEnd);
 
   size_t suboriginEnd = oldHost.find('.');
   // Suborigins cannot be empty.
@@ skipping 45 matching lines @@
                                                   int port) {
   if (port < 0 || port > MaxAllowedPort)
     return createUnique();
 
   DCHECK_EQ(host, decodeURLEscapeSequences(host));
 
   String portPart = port ? ":" + String::number(port) : String();
   return create(KURL(KURL(), protocol + "://" + host + portPart + "/"));
 }
 
+PassRefPtr<SecurityOrigin> SecurityOrigin::create(const String& protocol,
+                                                  const String& host,
+                                                  int port,
+                                                  const String& suborigin) {
+  RefPtr<SecurityOrigin> origin = create(protocol, host, port);
+  if (!suborigin.isEmpty())
+    origin->m_suborigin.setName(suborigin);
+  return origin.release();
+}
+
 bool SecurityOrigin::isSameSchemeHostPort(const SecurityOrigin* other) const {
   if (this == other)
     return true;
 
   if (isUnique() || other->isUnique())
     return false;
 
   if (m_host != other->m_host)
     return false;
 
@@ skipping 42 matching lines @@
       privilegeData->m_blockLocalAccessFromLocalOrigin;
 }
 
 void SecurityOrigin::setUniqueOriginIsPotentiallyTrustworthy(
     bool isUniqueOriginPotentiallyTrustworthy) {
   ASSERT(!isUniqueOriginPotentiallyTrustworthy || isUnique());
   m_isUniqueOriginPotentiallyTrustworthy = isUniqueOriginPotentiallyTrustworthy;
 }
 
 }  // namespace blink