Make Document::isSecureContext() work for OOPIFs

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 108 matching lines @@
 
 SecurityOrigin::SecurityOrigin(const KURL& url)
     : m_protocol(url.protocol().isNull() ? "" : url.protocol().lower())
     , m_host(url.host().isNull() ? "" : url.host().lower())
     , m_port(url.port())
     , m_effectivePort(url.port() ? url.port() : defaultPortForProtocol(m_protocol))
     , m_isUnique(false)
     , m_universalAccess(false)
     , m_domainWasSetInDOM(false)
     , m_blockLocalAccessFromLocalOrigin(false)
+    , m_isUniqueOriginPotentiallyTrustworthy(false)
+    , m_uniqueOriginShouldBypassSecureContextCheck(false)
 {
     // Suborigins are serialized into the host, so extract it if necessary.
     String suboriginName;
     if (deserializeSuboriginAndHost(m_host, suboriginName, m_host))
         addSuborigin(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();
 }
 
 SecurityOrigin::SecurityOrigin()
     : m_protocol("")
     , m_host("")
     , m_domain("")
     , m_suboriginName(WTF::String())
     , m_port(InvalidPort)
     , m_effectivePort(InvalidPort)
     , m_isUnique(true)
     , m_universalAccess(false)
     , m_domainWasSetInDOM(false)
     , m_canLoadLocalResources(false)
     , m_blockLocalAccessFromLocalOrigin(false)
+    , m_isUniqueOriginPotentiallyTrustworthy(false)
+    , m_uniqueOriginShouldBypassSecureContextCheck(false)
 {
 }
 
 SecurityOrigin::SecurityOrigin(const SecurityOrigin* other)
     : m_protocol(other->m_protocol.isolatedCopy())
     , m_host(other->m_host.isolatedCopy())
     , m_domain(other->m_domain.isolatedCopy())
     , m_suboriginName(other->m_suboriginName.isolatedCopy())
     , m_port(other->m_port)
     , m_effectivePort(other->m_effectivePort)
     , m_isUnique(other->m_isUnique)
     , m_universalAccess(other->m_universalAccess)
     , m_domainWasSetInDOM(other->m_domainWasSetInDOM)
     , m_canLoadLocalResources(other->m_canLoadLocalResources)
     , m_blockLocalAccessFromLocalOrigin(other->m_blockLocalAccessFromLocalOrigin)
+    , m_isUniqueOriginPotentiallyTrustworthy(other->m_isUniqueOriginPotentiallyTrustworthy)
+    , m_uniqueOriginShouldBypassSecureContextCheck(other->m_uniqueOriginShouldBypassSecureContextCheck)
 {
 }
 
 PassRefPtr<SecurityOrigin> SecurityOrigin::create(const KURL& url)
 {
     if (RefPtr<SecurityOrigin> origin = cachedOrigin(url))
         return origin.release();
 
     if (shouldTreatAsUniqueOrigin(url)) {
         RefPtr<SecurityOrigin> origin = adoptRef(new SecurityOrigin());
         return origin.release();
     }
 
     if (shouldUseInnerURL(url))
         return adoptRef(new SecurityOrigin(extractInnerURL(url)));
 
     return adoptRef(new SecurityOrigin(url));
 }
 
+PassRefPtr<SecurityOrigin> SecurityOrigin::createUnique(bool isPotentiallyTrustworthy, bool bypassSecureContextCheck)
+{
+    RefPtr<SecurityOrigin> origin = adoptRef(new SecurityOrigin());
+    ASSERT(origin->isUnique());
+    origin->m_isUniqueOriginPotentiallyTrustworthy = isPotentiallyTrustworthy;
+    origin->m_uniqueOriginShouldBypassSecureContextCheck = bypassSecureContextCheck;
+    return origin.release();
+}
+
 PassRefPtr<SecurityOrigin> SecurityOrigin::createUnique()
 {
-    RefPtr<SecurityOrigin> origin = adoptRef(new SecurityOrigin());
-    ASSERT(origin->isUnique());
-    return origin.release();
+    return createUnique(false, false);
 }
 
 void SecurityOrigin::addSuborigin(const String& suborigin)
 {
     ASSERT(RuntimeEnabledFeatures::suboriginsEnabled());
     // Changing suborigins midstream is bad. Very bad. It should not happen.
     // This is, in fact, one of the very basic invariants that makes suborigins
     // an effective security tool.
     RELEASE_ASSERT(m_suboriginName.isNull() || m_suboriginName == suborigin);
     m_suboriginName = suborigin;
@@ skipping 143 matching lines @@
 
     if (SchemeRegistry::shouldTreatURLSchemeAsLocal(protocol))
         return canLoadLocalResources() || SecurityPolicy::isAccessToURLWhiteListed(this, url);
 
     return true;
 }
 
 bool SecurityOrigin::isPotentiallyTrustworthy() const
 {
     ASSERT(m_protocol != "data");
+
+    if (isUnique())
+        return m_isUniqueOriginPotentiallyTrustworthy;
+
     if (SchemeRegistry::shouldTreatURLSchemeAsSecure(m_protocol) || isLocal() || isLocalhost())
         return true;
 
     if (SecurityPolicy::isOriginWhiteListedTrustworthy(*this))
         return true;
 
     return false;
 }
 
 // static
 String SecurityOrigin::isPotentiallyTrustworthyErrorMessage()
 {
     return "Only secure origins are allowed (see: https://goo.gl/Y0ZkNV).";
 }
 
+void SecurityOrigin::setIsPotentiallyTrustworthySandboxedOrigin()
+{
+    ASSERT(isUnique());
+    m_isUniqueOriginPotentiallyTrustworthy = true;
+}
+
+bool SecurityOrigin::bypassSecureContextCheck() const
+{
+    if (isUnique())
+        return m_uniqueOriginShouldBypassSecureContextCheck;
+    return SchemeRegistry::schemeShouldBypassSecureContextCheck(protocol());
+}
+
 void SecurityOrigin::grantLoadLocalResources()
 {
     // Granting privileges to some, but not all, documents in a SecurityOrigin
     // is a security hazard because the documents without the privilege can
     // obtain the privilege by injecting script into the documents that have
     // been granted the privilege.
     m_canLoadLocalResources = true;
 }
 
 void SecurityOrigin::grantUniversalAccess()
@@ skipping 161 matching lines @@
 }
 
 void SecurityOrigin::transferPrivilegesFrom(PassOwnPtr<PrivilegeData> privilegeData)
 {
     m_universalAccess = privilegeData->m_universalAccess;
     m_canLoadLocalResources = privilegeData->m_canLoadLocalResources;
     m_blockLocalAccessFromLocalOrigin = privilegeData->m_blockLocalAccessFromLocalOrigin;
 }
 
 } // namespace blink