Assume SchemeRegistry only operates on lowercase schemes

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

 /*
  * Copyright (C) 2010 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
  *    notice, this list of conditions and the following disclaimer in the
@@ skipping 86 matching lines @@
   return schemes;
 }
 
 static URLSchemesSet& notAllowingJavascriptURLsSchemes() {
   DEFINE_STATIC_LOCAL_WITH_LOCK(URLSchemesSet, notAllowingJavascriptURLsSchemes,
                                 ());
   return notAllowingJavascriptURLsSchemes;
 }
 
 void SchemeRegistry::registerURLSchemeAsLocal(const String& scheme) {
+  DCHECK_EQ(scheme, scheme.lower());
   MutexLocker locker(mutex());
   localURLSchemes().add(scheme);
 }
 
 const URLSchemesSet& SchemeRegistry::localSchemes() {
   MutexLocker locker(mutex());
   return localURLSchemes();
 }
 
 static URLSchemesSet& CORSEnabledSchemes() {
@@ skipping 62 matching lines @@
 
   return allowedInReferrerSchemes;
 }
 
 void SchemeRegistry::initialize() {
   // Instantiate the mutex object.
   mutex();
 }
 
 bool SchemeRegistry::shouldTreatURLSchemeAsLocal(const String& scheme) {
+  DCHECK_EQ(scheme, scheme.lower());
   if (scheme.isEmpty())
     return false;
   MutexLocker locker(mutex());
   return localURLSchemes().contains(scheme);
 }
 
 void SchemeRegistry::registerURLSchemeAsNoAccess(const String& scheme) {
+  DCHECK_EQ(scheme, scheme.lower());
   MutexLocker locker(mutex());
   schemesWithUniqueOrigins().add(scheme);
 }
 
 bool SchemeRegistry::shouldTreatURLSchemeAsNoAccess(const String& scheme) {
+  DCHECK_EQ(scheme, scheme.lower());
   if (scheme.isEmpty())
     return false;
   MutexLocker locker(mutex());
   return schemesWithUniqueOrigins().contains(scheme);
 }
 
 void SchemeRegistry::registerURLSchemeAsDisplayIsolated(const String& scheme) {
+  DCHECK_EQ(scheme, scheme.lower());
   MutexLocker locker(mutex());
   displayIsolatedURLSchemes().add(scheme);
 }
 
 bool SchemeRegistry::shouldTreatURLSchemeAsDisplayIsolated(
     const String& scheme) {
+  DCHECK_EQ(scheme, scheme.lower());
   if (scheme.isEmpty())
     return false;
   MutexLocker locker(mutex());
   return displayIsolatedURLSchemes().contains(scheme);
 }
 
 void SchemeRegistry::registerURLSchemeAsRestrictingMixedContent(
     const String& scheme) {
+  DCHECK_EQ(scheme, scheme.lower());
   MutexLocker locker(mutex());
   mixedContentRestrictingSchemes().add(scheme);
 }
 
 bool SchemeRegistry::shouldTreatURLSchemeAsRestrictingMixedContent(
     const String& scheme) {
+  DCHECK_EQ(scheme, scheme.lower());
   if (scheme.isEmpty())
     return false;
   MutexLocker locker(mutex());
   return mixedContentRestrictingSchemes().contains(scheme);
 }
 
 void SchemeRegistry::registerURLSchemeAsSecure(const String& scheme) {
+  DCHECK_EQ(scheme, scheme.lower());
   MutexLocker locker(mutex());
   secureSchemes().add(scheme);
 }
 
 bool SchemeRegistry::shouldTreatURLSchemeAsSecure(const String& scheme) {
+  DCHECK_EQ(scheme, scheme.lower());
   if (scheme.isEmpty())
     return false;
   MutexLocker locker(mutex());
   return secureSchemes().contains(scheme);
 }
 
 void SchemeRegistry::registerURLSchemeAsEmptyDocument(const String& scheme) {
+  DCHECK_EQ(scheme, scheme.lower());
   MutexLocker locker(mutex());
   emptyDocumentSchemes().add(scheme);
 }
 
 bool SchemeRegistry::shouldLoadURLSchemeAsEmptyDocument(const String& scheme) {
+  DCHECK_EQ(scheme, scheme.lower());
   if (scheme.isEmpty())
     return false;
   MutexLocker locker(mutex());
   return emptyDocumentSchemes().contains(scheme);
 }
 
 void SchemeRegistry::setDomainRelaxationForbiddenForURLScheme(
     bool forbidden,
     const String& scheme) {
+  DCHECK_EQ(scheme, scheme.lower());
   if (scheme.isEmpty())
     return;
 
   MutexLocker locker(mutex());
   if (forbidden)
     schemesForbiddenFromDomainRelaxation().add(scheme);
   else
     schemesForbiddenFromDomainRelaxation().remove(scheme);
 }
 
 bool SchemeRegistry::isDomainRelaxationForbiddenForURLScheme(
     const String& scheme) {
+  DCHECK_EQ(scheme, scheme.lower());
   if (scheme.isEmpty())
     return false;
   MutexLocker locker(mutex());
   return schemesForbiddenFromDomainRelaxation().contains(scheme);
 }
 
 bool SchemeRegistry::canDisplayOnlyIfCanRequest(const String& scheme) {
-  return equalIgnoringASCIICase("blob", scheme) ||
-         equalIgnoringASCIICase("filesystem", scheme);
+  DCHECK_EQ(scheme, scheme.lower());
+  return scheme == "blob" || scheme == "filesystem";
 }
 
 void SchemeRegistry::registerURLSchemeAsNotAllowingJavascriptURLs(
     const String& scheme) {
+  DCHECK_EQ(scheme, scheme.lower());
   MutexLocker locker(mutex());
   notAllowingJavascriptURLsSchemes().add(scheme);
 }
 
 bool SchemeRegistry::shouldTreatURLSchemeAsNotAllowingJavascriptURLs(
     const String& scheme) {
+  DCHECK_EQ(scheme, scheme.lower());
   if (scheme.isEmpty())
     return false;
   MutexLocker locker(mutex());
   return notAllowingJavascriptURLsSchemes().contains(scheme);
 }
 
 void SchemeRegistry::registerURLSchemeAsCORSEnabled(const String& scheme) {
+  DCHECK_EQ(scheme, scheme.lower());
   MutexLocker locker(mutex());
   CORSEnabledSchemes().add(scheme);
 }
 
 bool SchemeRegistry::shouldTreatURLSchemeAsCORSEnabled(const String& scheme) {
+  DCHECK_EQ(scheme, scheme.lower());
   if (scheme.isEmpty())
     return false;
   MutexLocker locker(mutex());
   return CORSEnabledSchemes().contains(scheme);
 }
 
 String SchemeRegistry::listOfCORSEnabledURLSchemes() {
   StringBuilder builder;
   bool addSeparator = false;
   URLSchemesSet schemes;
   {
     MutexLocker locker(mutex());
     schemes = CORSEnabledSchemes();
   }
   for (const auto& scheme : schemes) {
     if (addSeparator)
       builder.append(", ");
     else
       addSeparator = true;
 
     builder.append(scheme);
   }
   return builder.toString();
 }
 
 bool SchemeRegistry::shouldTreatURLSchemeAsLegacy(const String& scheme) {
-  return equalIgnoringASCIICase("ftp", scheme) ||
-         equalIgnoringASCIICase("gopher", scheme);
+  return scheme == "ftp" || scheme == "gopher";
 }
 
 void SchemeRegistry::registerURLSchemeAsAllowingServiceWorkers(
     const String& scheme) {
+  DCHECK_EQ(scheme, scheme.lower());
   MutexLocker locker(mutex());
   serviceWorkerSchemes().add(scheme);
 }
 
 bool SchemeRegistry::shouldTreatURLSchemeAsAllowingServiceWorkers(
     const String& scheme) {
+  DCHECK_EQ(scheme, scheme.lower());
   if (scheme.isEmpty())
     return false;
   MutexLocker locker(mutex());
   return serviceWorkerSchemes().contains(scheme);
 }
 
 void SchemeRegistry::registerURLSchemeAsSupportingFetchAPI(
     const String& scheme) {
+  DCHECK_EQ(scheme, scheme.lower());
   MutexLocker locker(mutex());
   fetchAPISchemes().add(scheme);
 }
 
 bool SchemeRegistry::shouldTreatURLSchemeAsSupportingFetchAPI(
     const String& scheme) {
+  DCHECK_EQ(scheme, scheme.lower());
   if (scheme.isEmpty())
     return false;
   MutexLocker locker(mutex());
   return fetchAPISchemes().contains(scheme);
 }
 
 void SchemeRegistry::registerURLSchemeAsFirstPartyWhenTopLevel(
     const String& scheme) {
+  DCHECK_EQ(scheme, scheme.lower());
   MutexLocker locker(mutex());
   firstPartyWhenTopLevelSchemes().add(scheme);
 }
 
 void SchemeRegistry::removeURLSchemeAsFirstPartyWhenTopLevel(
     const String& scheme) {
+  DCHECK_EQ(scheme, scheme.lower());
   MutexLocker locker(mutex());
   firstPartyWhenTopLevelSchemes().remove(scheme);
 }
 
 bool SchemeRegistry::shouldTreatURLSchemeAsFirstPartyWhenTopLevel(
     const String& scheme) {
+  DCHECK_EQ(scheme, scheme.lower());
   if (scheme.isEmpty())
     return false;
   MutexLocker locker(mutex());
   return firstPartyWhenTopLevelSchemes().contains(scheme);
 }
 
 void SchemeRegistry::registerURLSchemeAsAllowedForReferrer(
     const String& scheme) {
+  DCHECK_EQ(scheme, scheme.lower());
   MutexLocker locker(mutex());
   allowedInReferrerSchemes().add(scheme);
 }
 
 void SchemeRegistry::removeURLSchemeAsAllowedForReferrer(const String& scheme) {
   MutexLocker locker(mutex());
   allowedInReferrerSchemes().remove(scheme);
 }
 
 bool SchemeRegistry::shouldTreatURLSchemeAsAllowedForReferrer(
     const String& scheme) {
+  DCHECK_EQ(scheme, scheme.lower());
   if (scheme.isEmpty())
     return false;
   MutexLocker locker(mutex());
   return allowedInReferrerSchemes().contains(scheme);
 }
 
 void SchemeRegistry::registerURLSchemeAsBypassingContentSecurityPolicy(
     const String& scheme,
     PolicyAreas policyAreas) {
+  DCHECK_EQ(scheme, scheme.lower());
   MutexLocker locker(mutex());
   ContentSecurityPolicyBypassingSchemes().add(scheme, policyAreas);
 }
 
 void SchemeRegistry::removeURLSchemeRegisteredAsBypassingContentSecurityPolicy(
     const String& scheme) {
+  DCHECK_EQ(scheme, scheme.lower());
   MutexLocker locker(mutex());
   ContentSecurityPolicyBypassingSchemes().remove(scheme);
 }
 
 bool SchemeRegistry::schemeShouldBypassContentSecurityPolicy(
     const String& scheme,
     PolicyAreas policyAreas) {
   ASSERT(policyAreas != PolicyAreaNone);
   if (scheme.isEmpty() || policyAreas == PolicyAreaNone)
     return false;
 
   // get() returns 0 (PolicyAreaNone) if there is no entry in the map.
   // Thus by default, schemes do not bypass CSP.
   MutexLocker locker(mutex());
   return (ContentSecurityPolicyBypassingSchemes().get(scheme) & policyAreas) ==
          policyAreas;
 }
 
 void SchemeRegistry::registerURLSchemeBypassingSecureContextCheck(
     const String& scheme) {
+  DCHECK_EQ(scheme, scheme.lower());
   MutexLocker locker(mutex());
   secureContextBypassingSchemes().add(scheme.lower());
 }
 
 bool SchemeRegistry::schemeShouldBypassSecureContextCheck(
     const String& scheme) {
   if (scheme.isEmpty())
     return false;
   MutexLocker locker(mutex());
   return secureContextBypassingSchemes().contains(scheme.lower());
 }
 
 }  // namespace blink