Rename SecurityOriginCache to URLSecurityOriginMap

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 14 matching lines @@
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #include "platform/weborigin/SecurityOrigin.h"
 
 #include "platform/RuntimeEnabledFeatures.h"
 #include "platform/weborigin/KURL.h"
 #include "platform/weborigin/KnownPorts.h"
 #include "platform/weborigin/SchemeRegistry.h"
-#include "platform/weborigin/SecurityOriginCache.h"
 #include "platform/weborigin/SecurityPolicy.h"
+#include "platform/weborigin/URLSecurityOriginMap.h"
 #include "url/url_canon_ip.h"
 #include "wtf/HexNumber.h"
 #include "wtf/NotFound.h"
 #include "wtf/PtrUtil.h"
 #include "wtf/StdLibExtras.h"
 #include "wtf/text/StringBuilder.h"
 #include <memory>
 
 namespace blink {
 
 const int InvalidPort = 0;
 const int MaxAllowedPort = 65535;
 
-static SecurityOriginCache* s_originCache = 0;
+static URLSecurityOriginMap* s_urlOriginMap = 0;
 
-static SecurityOrigin* cachedOrigin(const KURL& url)
+static SecurityOrigin* getOriginFromMap(const KURL& url)
 {
-    if (s_originCache)
-        return s_originCache->cachedOrigin(url);
-    return 0;
+    if (s_urlOriginMap)
+        return s_urlOriginMap->getOrigin(url);
+    return nullptr;
 }
 
 bool SecurityOrigin::shouldUseInnerURL(const KURL& url)
 {
     // FIXME: Blob URLs don't have inner URLs. Their form is "blob:<inner-origin>/<UUID>", so treating the part after "blob:" as a URL is incorrect.
     if (url.protocolIs("blob"))
         return true;
     if (url.protocolIs("filesystem"))
         return true;
     return false;
 }
 
 // In general, extracting the inner URL varies by scheme. It just so happens
 // that all the URL schemes we currently support that use inner URLs for their
 // security origin can be parsed using this algorithm.
 KURL SecurityOrigin::extractInnerURL(const KURL& url)
 {
     if (url.innerURL())
         return *url.innerURL();
     // FIXME: Update this callsite to use the innerURL member function when
     // we finish implementing it.
     return KURL(ParsedURLString, url.path());
 }
 
-void SecurityOrigin::setCache(SecurityOriginCache* originCache)
+void SecurityOrigin::setMap(URLSecurityOriginMap* map)
 {
-    s_originCache = originCache;
+    s_urlOriginMap = map;
 }
 
 static bool shouldTreatAsUniqueOrigin(const KURL& url)
 {
     if (!url.isValid())
         return true;
 
     // FIXME: Do we need to unwrap the URL further?
     KURL relevantURL;
     if (SecurityOrigin::shouldUseInnerURL(url)) {
@@ skipping 74 matching lines @@
     , 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)
 {
 }
 
 PassRefPtr<SecurityOrigin> SecurityOrigin::create(const KURL& url)
 {
-    if (RefPtr<SecurityOrigin> origin = cachedOrigin(url))
+    if (RefPtr<SecurityOrigin> origin = getOriginFromMap(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)));
 
@@ skipping 85 matching lines @@
     ASSERT(isLocal() && other->isLocal());
 
     return !m_blockLocalAccessFromLocalOrigin && !other->m_blockLocalAccessFromLocalOrigin;
 }
 
 bool SecurityOrigin::canRequest(const KURL& url) const
 {
     if (m_universalAccess)
         return true;
 
-    if (cachedOrigin(url) == this)
+    if (getOriginFromMap(url) == this)
         return true;
 
     if (isUnique())
         return false;
 
     RefPtr<SecurityOrigin> targetOrigin = SecurityOrigin::create(url);
 
     if (targetOrigin->isUnique())
         return false;
 
@@ skipping 289 matching lines @@
     m_blockLocalAccessFromLocalOrigin = privilegeData->m_blockLocalAccessFromLocalOrigin;
 }
 
 void SecurityOrigin::setUniqueOriginIsPotentiallyTrustworthy(bool isUniqueOriginPotentiallyTrustworthy)
 {
     ASSERT(!isUniqueOriginPotentiallyTrustworthy || isUnique());
     m_isUniqueOriginPotentiallyTrustworthy = isUniqueOriginPotentiallyTrustworthy;
 }
 
 } // namespace blink