Tidy up ScriptLoader (MIME) type matching.

third_party/WebKit/Source/core/dom/ScriptLoader.cpp

 /*
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
  *           (C) 2001 Dirk Mueller (mueller@kde.org)
  * Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008 Apple Inc. All rights
  * reserved.
  * Copyright (C) 2008 Nikolas Zimmermann <zimmermann@kde.org>
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
@@ skipping 111 matching lines @@
   m_forceAsync = false;
 }
 
 void ScriptLoader::detach() {
   if (!m_pendingScript)
     return;
   m_pendingScript->dispose();
   m_pendingScript = nullptr;
 }
 
-// Helper function. Must take a lowercase language as input.
 static bool isLegacySupportedJavaScriptLanguage(const String& language) {
   // Mozilla 1.8 accepts javascript1.0 - javascript1.7, but WinIE 7 accepts only
   // javascript1.1 - javascript1.3.
   // Mozilla 1.8 and WinIE 7 both accept javascript and livescript.
   // WinIE 7 accepts ecmascript and jscript, but Mozilla 1.8 doesn't.
   // Neither Mozilla 1.8 nor WinIE 7 accept leading or trailing whitespace.
   // We want to accept all the values that either of these browsers accept, but
   // not other values.
 
   // FIXME: This function is not HTML5 compliant. These belong in the MIME
   // registry as "text/javascript<version>" entries.
-  DCHECK_EQ(language, language.lower());
-  return language == "javascript" || language == "javascript1.0" ||
-         language == "javascript1.1" || language == "javascript1.2" ||
-         language == "javascript1.3" || language == "javascript1.4" ||
-         language == "javascript1.5" || language == "javascript1.6" ||
-         language == "javascript1.7" || language == "livescript" ||
-         language == "ecmascript" || language == "jscript";
+  return equalIgnoringASCIICase(language, "javascript") ||
+         equalIgnoringASCIICase(language, "javascript1.0") ||
+         equalIgnoringASCIICase(language, "javascript1.1") ||
+         equalIgnoringASCIICase(language, "javascript1.2") ||
+         equalIgnoringASCIICase(language, "javascript1.3") ||
+         equalIgnoringASCIICase(language, "javascript1.4") ||
+         equalIgnoringASCIICase(language, "javascript1.5") ||
+         equalIgnoringASCIICase(language, "javascript1.6") ||
+         equalIgnoringASCIICase(language, "javascript1.7") ||
+         equalIgnoringASCIICase(language, "livescript") ||
+         equalIgnoringASCIICase(language, "ecmascript") ||
+         equalIgnoringASCIICase(language, "jscript");
 }
 
 void ScriptLoader::dispatchErrorEvent() {
   m_element->dispatchEvent(Event::create(EventTypeNames::error));
 }
 
 void ScriptLoader::dispatchLoadEvent() {
   if (ScriptLoaderClient* client = this->client())
     client->dispatchLoadEvent();
   setHaveFiredLoadEvent(true);
 }
 
 bool ScriptLoader::isValidScriptTypeAndLanguage(
     const String& type,
     const String& language,
     LegacyTypeSupport supportLegacyTypes) {
   // FIXME: isLegacySupportedJavaScriptLanguage() is not valid HTML5. It is used
   // here to maintain backwards compatibility with existing layout tests. The
   // specific violations are:
   // - Allowing type=javascript. type= should only support MIME types, such as
   //   text/javascript.
   // - Allowing a different set of languages for language= and type=. language=
   //   supports Javascript 1.1 and 1.4-1.6, but type= does not.
   if (type.isEmpty()) {
-    String lowerLanguage = language.lower();
-    return language.isEmpty()  // assume text/javascript.
-           || MIMETypeRegistry::isSupportedJavaScriptMIMEType("text/" +
-                                                              lowerLanguage) ||
-           isLegacySupportedJavaScriptLanguage(lowerLanguage);
+    return language.isEmpty() ||  // assume text/javascript.
+           MIMETypeRegistry::isSupportedJavaScriptMIMEType("text/" +
+                                                           language) ||
+           isLegacySupportedJavaScriptLanguage(language);
   } else if (RuntimeEnabledFeatures::moduleScriptsEnabled() &&
              type == "module") {
     return true;
   } else if (MIMETypeRegistry::isSupportedJavaScriptMIMEType(
                  type.stripWhiteSpace()) ||
              (supportLegacyTypes == AllowLegacyTypeInTypeAttribute &&
-              isLegacySupportedJavaScriptLanguage(type.lower()))) {
+              isLegacySupportedJavaScriptLanguage(type))) {
     return true;
   }
 
   return false;
 }
 
 bool ScriptLoader::isScriptTypeSupported(
     LegacyTypeSupport supportLegacyTypes) const {
   return isValidScriptTypeAndLanguage(client()->typeAttributeValue(),
                                       client()->languageAttributeValue(),
@@ skipping 197 matching lines @@
 bool isHTMLScriptLoader(Element* element) {
   DCHECK(element);
   return isHTMLScriptElement(*element);
 }
 
 bool isSVGScriptLoader(Element* element) {
   DCHECK(element);
   return isSVGScriptElement(*element);
 }
 
-void ScriptLoader::logScriptMimetype(ScriptResource* resource,
-                                     LocalFrame* frame,
-                                     String mimetype) {
-  String lowerMimetype = mimetype.lower();
-  bool text = lowerMimetype.startsWith("text/");
-  bool application = lowerMimetype.startsWith("application/");
-  bool expectedJs =
-      MIMETypeRegistry::isSupportedJavaScriptMIMEType(lowerMimetype) ||
-      (text && isLegacySupportedJavaScriptLanguage(lowerMimetype.substring(5)));
-  bool sameOrigin =
-      m_element->document().getSecurityOrigin()->canRequest(m_resource->url());
-  if (expectedJs) {
+void ScriptLoader::logScriptMIMEType(LocalFrame* frame,
+                                     ScriptResource* resource,
+                                     const String& mimeType) {
+  if (MIMETypeRegistry::isSupportedJavaScriptMIMEType(mimeType))
     return;
-  }
+  bool isText = mimeType.startsWith("text/", TextCaseASCIIInsensitive);
+  if (isText && isLegacySupportedJavaScriptLanguage(mimeType.substring(5)))
+    return;
+  bool isSameOrigin =
+      m_element->document().getSecurityOrigin()->canRequest(resource->url());
+  bool isApplication =
+      !isText && mimeType.startsWith("application/", TextCaseASCIIInsensitive);
+
   UseCounter::Feature feature =
-      sameOrigin
-          ? (text ? UseCounter::SameOriginTextScript
-                  : application ? UseCounter::SameOriginApplicationScript
-                                : UseCounter::SameOriginOtherScript)
-          : (text ? UseCounter::CrossOriginTextScript
-                  : application ? UseCounter::CrossOriginApplicationScript
-                                : UseCounter::CrossOriginOtherScript);
+      isSameOrigin
+          ? (isText ? UseCounter::SameOriginTextScript
+                    : isApplication ? UseCounter::SameOriginApplicationScript
+                                    : UseCounter::SameOriginOtherScript)
+          : (isText ? UseCounter::CrossOriginTextScript
+                    : isApplication ? UseCounter::CrossOriginApplicationScript
+                                    : UseCounter::CrossOriginOtherScript);
+
   UseCounter::count(frame, feature);
 }
 
 bool ScriptLoader::executeScript(const ScriptSourceCode& sourceCode) {
   double scriptExecStartTime = monotonicallyIncreasingTime();
   bool result = doExecuteScript(sourceCode);
 
   // NOTE: we do not check m_willBeParserExecuted here, since
   // m_willBeParserExecuted is false for inline scripts, and we want to
   // include inline script execution time as part of parser blocked script
@@ skipping 44 matching lines @@
         contextDocument->addConsoleMessage(ConsoleMessage::create(
             SecurityMessageSource, ErrorMessageLevel,
             "Refused to execute script from '" +
                 resource->url().elidedString() + "' because its MIME type ('" +
                 resource->httpContentType() + "') is not executable, and "
                                               "strict MIME type checking is "
                                               "enabled."));
         return false;
       }
 
-      String mimetype = resource->httpContentType();
-      if (mimetype.startsWith("image/") || mimetype == "text/csv" ||
-          mimetype.startsWith("audio/") || mimetype.startsWith("video/")) {
+      String mimeType = resource->httpContentType();
+      if (mimeType.startsWith("image/") || mimeType == "text/csv" ||
+          mimeType.startsWith("audio/") || mimeType.startsWith("video/")) {
         contextDocument->addConsoleMessage(ConsoleMessage::create(
             SecurityMessageSource, ErrorMessageLevel,
             "Refused to execute script from '" +
                 resource->url().elidedString() + "' because its MIME type ('" +
-                mimetype + "') is not executable."));
-        if (mimetype.startsWith("image/"))
+                mimeType + "') is not executable."));
+        if (mimeType.startsWith("image/"))
           UseCounter::count(frame, UseCounter::BlockedSniffingImageToScript);
-        else if (mimetype.startsWith("audio/"))
+        else if (mimeType.startsWith("audio/"))
           UseCounter::count(frame, UseCounter::BlockedSniffingAudioToScript);
-        else if (mimetype.startsWith("video/"))
+        else if (mimeType.startsWith("video/"))
           UseCounter::count(frame, UseCounter::BlockedSniffingVideoToScript);
-        else if (mimetype == "text/csv")
+        else if (mimeType == "text/csv")
           UseCounter::count(frame, UseCounter::BlockedSniffingCSVToScript);
         return false;
       }
 
-      logScriptMimetype(resource, frame, mimetype);
+      logScriptMIMEType(frame, resource, mimeType);
     }
   }
 
   // FIXME: Can this be moved earlier in the function?
   // Why are we ever attempting to execute scripts without a frame?
   if (!frame)
     return true;
 
   AccessControlStatus accessControlStatus = NotSharableCrossOrigin;
   if (!m_isExternalScript) {
@@ skipping 125 matching lines @@
   if (isHTMLScriptLoader(element))
     return toHTMLScriptElement(element)->loader();
 
   if (isSVGScriptLoader(element))
     return toSVGScriptElement(element)->loader();
 
   return 0;
 }
 
 }  // namespace blink