Introduce ScriptLoader::script_type_

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 139 matching lines @@
 
 void ScriptLoader::DispatchErrorEvent() {
   element_->DispatchErrorEvent();
 }
 
 void ScriptLoader::DispatchLoadEvent() {
   element_->DispatchLoadEvent();
   SetHaveFiredLoadEvent(true);
 }
 
-bool ScriptLoader::IsValidScriptTypeAndLanguage(
+namespace {
+
+bool IsValidClassicScriptTypeAndLanguage(
     const String& type,
     const String& language,
-    LegacyTypeSupport support_legacy_types) {
+    ScriptLoader::LegacyTypeSupport support_legacy_types) {
   // 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()) {
     return language.IsEmpty() ||  // assume text/javascript.
            MIMETypeRegistry::IsSupportedJavaScriptMIMEType("text/" +
                                                            language) ||
            MIMETypeRegistry::IsLegacySupportedJavaScriptLanguage(language);
-  } else if (RuntimeEnabledFeatures::moduleScriptsEnabled() &&
-             type == "module") {
-    return true;
   } else if (MIMETypeRegistry::IsSupportedJavaScriptMIMEType(
                  type.StripWhiteSpace()) ||
-             (support_legacy_types == kAllowLegacyTypeInTypeAttribute &&
+             (support_legacy_types ==
+                  ScriptLoader::kAllowLegacyTypeInTypeAttribute &&
               MIMETypeRegistry::IsLegacySupportedJavaScriptLanguage(type))) {
     return true;
   }
 
   return false;
 }
 
-bool ScriptLoader::IsScriptTypeSupported(
-    LegacyTypeSupport support_legacy_types) const {
+}  // namespace
+
+// Step 6 of https://html.spec.whatwg.org/#prepare-a-script
+bool ScriptLoader::IsValidScriptTypeAndLanguage(
+    const String& type,
+    const String& language,
+    LegacyTypeSupport support_legacy_types,
+    ScriptType& out_script_type) {
+  if (IsValidClassicScriptTypeAndLanguage(type, language,
+                                          support_legacy_types)) {
+    // - "If the script block's type string is an ASCII case-insensitive match
+    //    for any JavaScript MIME type, the script's type is "classic"."
+    // TODO(hiroshige): Annotate and/or cleanup this step.
+    out_script_type = ScriptType::kClassic;
+    return true;
+  }
+
+  if (RuntimeEnabledFeatures::moduleScriptsEnabled() && type == "module") {
+    // - "If the script block's type string is an ASCII case-insensitive match
+    //    for the string "module", the script's type is "module"."
+    out_script_type = ScriptType::kModule;
+    return true;
+  }
+
+  // - "If neither of the above conditions are true, then abort these steps
+  //    at this point. No script is executed."
+  return false;
+}
+
+bool ScriptLoader::IsScriptTypeSupported(LegacyTypeSupport support_legacy_types,
+                                         ScriptType& out_script_type) const {
   return IsValidScriptTypeAndLanguage(element_->TypeAttributeValue(),
                                       element_->LanguageAttributeValue(),
-                                      support_legacy_types);
+                                      support_legacy_types, out_script_type);
 }
 
 // https://html.spec.whatwg.org/#prepare-a-script
 bool ScriptLoader::PrepareScript(const TextPosition& script_start_position,
                                  LegacyTypeSupport support_legacy_types) {
   // 1. "If the script element is marked as having "already started", then
   //     abort these steps at this point. The script is not executed."
   if (already_started_)
     return false;
 
@@ skipping 20 matching lines @@
   // FIXME: HTML5 spec says we should check that all children are either
   // comments or empty text nodes.
   if (!element_->HasSourceAttribute() && !element_->HasChildren())
     return false;
 
   // 5. "If the element is not connected, then abort these steps.
   //     The script is not executed."
   if (!element_->IsConnected())
     return false;
 
-  // 6.
-  // TODO(hiroshige): Annotate and/or cleanup this step.
-  if (!IsScriptTypeSupported(support_legacy_types))
+  // 6. "Determine the script's type as follows:"
+  // |script_type_| is set here.
+  if (!IsScriptTypeSupported(support_legacy_types, script_type_))
     return false;
 
   // 7. "If was-parser-inserted is true,
   //     then flag the element as "parser-inserted" again,
   //     and set the element's "non-blocking" flag to false."
   if (was_parser_inserted) {
     parser_inserted_ = true;
     non_blocking_ = false;
   }
 
@@ skipping 10 matching lines @@
   if (!element_document.ExecutingFrame())
     return false;
   if (!context_document || !context_document->ExecutingFrame())
     return false;
 
   // 10. "If scripting is disabled for the script element, then abort these
   //      steps at this point. The script is not executed."
   if (!context_document->CanExecuteScripts(kAboutToExecuteScript))
     return false;
 
+  // 11. "If the script element has a nomodule content attribute
+  //      and the script's type is "classic", then abort these steps.
+  //      The script is not executed."
+  // TODO(japhet): Implement this step.
+
   // 13.
   if (!IsScriptForEventSupported())
     return false;
 
   // 14. "If the script element has a charset attribute,
   //      then let encoding be the result of
   //      getting an encoding from the value of the charset attribute."
   //     "If the script element does not have a charset attribute,
   //      or if getting an encoding failed, let encoding
   //      be the same as the encoding of the script element's node document."
@@ skipping 504 matching lines @@
   //     then abort these steps at this point. The script is not executed.
   return DeprecatedEqualIgnoringCase(event_attribute, "onload") ||
          DeprecatedEqualIgnoringCase(event_attribute, "onload()");
 }
 
 String ScriptLoader::ScriptContent() const {
   return element_->TextFromChildren();
 }
 
 }  // namespace blink