Attachment 294805 Details for Bug 148897 – Patch

[patch] Patch

bug-148897-20161115142106.patch (text/plain), 236.94 KB, created by Yusuke Suzuki on 2016-11-14 21:21:08 PST

(hide)

Description:

Filename:

MIME Type:

Creator: Yusuke Suzuki

Created: 2016-11-14 21:21:08 PST

Size: 236.94 KB

patch

obsolete

>Subversion Revision: 208726
>diff --git a/Source/WebCore/ChangeLog b/Source/WebCore/ChangeLog
>index 1c0b1938de9a832217cc93c73fb77d442d348037..597d9517487ab7e3eceba109930e2435424a4fee 100644
>--- a/Source/WebCore/ChangeLog
>+++ b/Source/WebCore/ChangeLog
>@@ -1,3 +1,241 @@
>+2016-11-14  Yusuke Suzuki  <utatane.tea@gmail.com>
>+
>+        [ES6] Integrate ES6 Modules into WebCore
>+        https://bugs.webkit.org/show_bug.cgi?id=148897
>+
>+        Reviewed by NOBODY (OOPS!).
>+
>+        This patch introduces ES6 Modules into WebCore. We integrate JSC's JSModuleLoader into WebCore.
>+        JSC constructs the module loader pipeline by the chains of the promises. To handle this,
>+        the following components are added.
>+
>+            1. CachedModuleScript
>+
>+                CachedModuleScript wraps the promise based JSModuleLoader pipeline and offers
>+                similar APIs to CachedScript. ScriptElement and PendingScript interact with
>+                CachedModuleScript when the script tag is the module tag instead of CachedScript.
>+                ScriptElement and PendingScript will receive the notification from
>+                CachedModuleScript by implementing CachedModuleScriptClient.
>+
>+            2. ScriptModuleLoader
>+
>+                This is the module loader instantiated per document. It manages fetching and
>+                offers the callbacks for the JSC's JSModuleLoader implementation. ScriptModuleLoader
>+                will fetch the resource by creating CachedModuleScriptLoader per resource. ScriptModuleLoader
>+                will receive the notification by implementing CachedModuleScriptLoaderClient. When the
>+                resource is fetched, the module loader will drive the promise resolve/reject chain.
>+
>+            3. CachedModuleScriptLoader
>+
>+                This fetches the resource by using CachedScript. Using CachedScript means that it
>+                automatically reports the resource to the inspector. CachedModuleScriptLoader notify to
>+                ScriptModuleLoader when the resource is fetched.
>+
>+        One tricky point is that the fetch requests issued from one module-graph should share the same
>+        nonce, crossorigin attributes etc.
>+
>+            Here, we wrote the module graph like `A -> B (A depends on B)`.
>+
>+            <script tag> -> A -> B -> C -> D
>+
>+        When fetching A, B, C, and D modules, we need to set the same nonce, crossorigin etc. configuration
>+        derived from the original script tag. So per module-graph information should be shared throughout
>+        the module loader pipeline. To do so, JSC's module loader implementation can take the value called
>+        `initiator`. Since the loader will propagate & share this `initiator` throughout the pipeline,
>+        we can transfer and share some metadata. Currently, we pass the JSWrapper of the script tag as the
>+        initiator. Each fetch request is created by using this initiator script element.
>+
>+        More integration into the inspector should be done in the subsequent patch.
>+
>+        * CMakeLists.txt:
>+        * WebCore.xcodeproj/project.pbxproj:
>+        * bindings/js/CachedModuleScript.cpp: Added.
>+        CachedModuleScript offers similar interface to CachedScript to make ScriptElement things easier. It encapsulates the
>+        detail of the JSC JSModuleLoader that this module loader is driven by the chain of the promises. CachedModuleScript's
>+        callbacks are called from the promise's handlers configured in ScriptController::loadModuleScript.
>+        (WebCore::CachedModuleScript::create):
>+        (WebCore::CachedModuleScript::CachedModuleScript):
>+        (WebCore::CachedModuleScript::load):
>+        (WebCore::CachedModuleScript::notifyLoadCompleted):
>+        (WebCore::CachedModuleScript::notifyLoadFailed):
>+        (WebCore::CachedModuleScript::notifyLoadWasCanceled):
>+        (WebCore::CachedModuleScript::notifyClientFinished):
>+        (WebCore::CachedModuleScript::addClient):
>+        (WebCore::CachedModuleScript::removeClient):
>+        * bindings/js/CachedModuleScript.h: Added.
>+        (WebCore::CachedModuleScript::moduleKey):
>+        (WebCore::CachedModuleScript::error):
>+        (WebCore::CachedModuleScript::wasCanceled):
>+        (WebCore::CachedModuleScript::isLoaded):
>+        (WebCore::CachedModuleScript::nonce):
>+        (WebCore::CachedModuleScript::crossOriginMode):
>+        Save nonce and crossorigin attributes when we start ScriptElement::prepareScript.
>+        * bindings/js/CachedModuleScriptClient.h: Copied from Source/WebCore/dom/LoadableScript.h.
>+        (WebCore::CachedModuleScriptClient::~CachedModuleScriptClient):
>+        * bindings/js/CachedModuleScriptLoader.cpp: Added.
>+        CachedModuleScriptLoader is responsible to fetching the resource for the module script. It uses propagated `initiator`
>+        to create the request. This initiator is the JS wrapper of the script element issuing this fetching request. The name
>+        `initiator` is derived from the request.setInitiator(). Once the resource is fetched, the fetcher will notify to the
>+        client. Currently, ScriptModuleLoader implements this client interface.
>+        (WebCore::CachedModuleScriptLoader::create):
>+        (WebCore::CachedModuleScriptLoader::CachedModuleScriptLoader):
>+        (WebCore::CachedModuleScriptLoader::~CachedModuleScriptLoader):
>+        (WebCore::CachedModuleScriptLoader::load):
>+        Create the request. We call ScriptElement::requestCachedScript to initiate a new fetching request. At that time,
>+        nonce and crossorigin (and charset) attributes of this element are applied to the new request.
>+        (WebCore::CachedModuleScriptLoader::notifyFinished):
>+        * bindings/js/CachedModuleScriptLoader.h: Copied from Source/WebCore/bindings/js/ScriptModuleLoader.h.
>+        * bindings/js/CachedModuleScriptLoaderClient.h: Copied from Source/WebCore/dom/LoadableScript.h.
>+        (WebCore::CachedModuleScriptLoaderClient::~CachedModuleScriptLoaderClient):
>+        * bindings/js/CachedScriptSourceProvider.h:
>+        (WebCore::CachedScriptSourceProvider::create):
>+        (WebCore::CachedScriptSourceProvider::CachedScriptSourceProvider):
>+        (WebCore::makeSource):
>+        * bindings/js/JSBindingsAllInOne.cpp:
>+        * bindings/js/JSDOMBinding.cpp:
>+        (WebCore::retrieveErrorMessage):
>+        (WebCore::reportException):
>+        * bindings/js/JSDOMBinding.h:
>+        * bindings/js/JSMainThreadExecState.h:
>+        (WebCore::JSMainThreadExecState::loadModule):
>+        (WebCore::JSMainThreadExecState::linkAndEvaluateModule):
>+        * bindings/js/ScriptController.cpp:
>+        (WebCore::ScriptController::ScriptController):
>+        (WebCore::ScriptController::evaluateInWorld):
>+        (WebCore::ScriptController::loadModuleScriptInWorld):
>+        (WebCore::ScriptController::loadModuleScript):
>+        This just performs loading and not executing the module graph. Once the module graph is loaded, it is notified to
>+        the given CachedModuleScript.
>+        (WebCore::ScriptController::linkAndEvaluateModuleScriptInWorld):
>+        (WebCore::ScriptController::linkAndEvaluateModuleScript):
>+        This executes the linking and evaluation of the already instantiated module graph. After loading the module graph,
>+        we call this function for the module to evaluate it. This is called from ScriptElement::executeModuleScript.
>+        (WebCore::ScriptController::evaluateModule):
>+        Every time we evaluate the module, the ScriptModuleLoader::evaluate hook is called. So the loader calls this function
>+        to actually evaluate the module.
>+        (WebCore::jsValueToModuleKey):
>+        (WebCore::ScriptController::setupModuleScriptHandlers):
>+        The JSC's module loader is driven by the chain of the promise. So here, we convert this to CachedModuleScript /
>+        CachedModuleScriptClient style and encapsulate the details. This encapsulation makes CachedModuleScript similar
>+        to CachedScript and it makes things simple in the rest of WebCore. If the propagated error is already reported
>+        to the inspector, we receive moduleLoaderAlreadyReportedErrorSymbol as the error value. So at that case, we
>+        don't report it twice. If the rejection is caused due to the canceled fetching, moduleLoaderFetchingIsCanceledSymbol
>+        appears as the error value. In that case, we will call CachedModuleScript::notifyLoadWasCanceled.
>+        (WebCore::ScriptController::executeScript):
>+        * bindings/js/ScriptController.h:
>+        (WebCore::ScriptController::moduleLoaderAlreadyReportedErrorSymbol):
>+        (WebCore::ScriptController::moduleLoaderFetchingIsCanceledSymbol):
>+        * bindings/js/ScriptModuleLoader.cpp:
>+        We use DeferredWrapper to resolve promises used for the module pipeline. Thus, once the active DOM objects are
>+        suspended, the module loader propagation stops.
>+        (WebCore::ScriptModuleLoader::~ScriptModuleLoader):
>+        Clear the clients of the fetchers issued from this loader.
>+        (WebCore::ScriptModuleLoader::resolve):
>+        Resolve the module specifier (that is written in `import from "XXX"`) to the unique module key. We use URL
>+        string as module key. The edge case is that the module is inlined one. In that case, we don't have any URL
>+        for that. Instead of URL, we use symbol at that time.
>+        (WebCore::ScriptModuleLoader::fetch):
>+        Start fetching for the requested module. It returns the promise that is resolved when the fetching is done.
>+        The loader creates the fetcher, and the fetcher start loading the resource. Once the fetcher loads the resource,
>+        it notify to the loader through CachedModuleScriptLoaderClient interface. Since we pass the original script
>+        element as the `initiator` here, the fetcher can use this initiator to create the request. While the result of
>+        CachedResource has 3 variations (loaded, canceled, error occurred), Promise only tells us whether it is resolved
>+        or rejected. When CachedModuleScript gets the result from the promise chain, it needs to know which the result is.
>+        To transfer the canceled information, we reject the promise with the special symbol `moduleLoaderAlreadyReportedErrorSymbol`.
>+        This offers the way to distinguish the canceled error from the other errors.
>+        (WebCore::ScriptModuleLoader::evaluate):
>+        This is the hook function that is called when JSC's JSModuleLoader attempts to execute each module.
>+        (WebCore::ScriptModuleLoader::notifyFinished):
>+        This function is called when the fetcher completes. We will resolve the promise with the result of the fetching.
>+        The module loader pipeline is constructed as a chain of promises.
>+        Rejecting a promise when some error occurs is important because the execution flow of
>+        the promise chain is driven by "rejected" or "fulfilled" events.
>+        If the promise is not rejected while error occurs, reject handler won't be executed
>+        and all the subsequent promise chain will wait the result forever.
>+        As a result, even if the error is already reported to the inspector elsewhere,
>+        it should be propagated in the pipeline. For example, the error of loading
>+        CachedResource is already reported to the inspector by the loader. But we still need
>+        to reject the promise to propagate this error to the script element.
>+        At that time, we don't want to report the same error twice. When we propagate the error
>+        that is already reported to the inspector, we throw moduleLoaderAlreadyReportedErrorSymbol
>+        symbol instead. By comparing the thrown error with this symbol, we can distinguish errors raised
>+        when checking syntax of a module script from errors reported already.
>+        In the reject handler of the promise, we only report a error that is not this symbol.
>+        And mime type checking is done here since the module script always require this check.
>+        * bindings/js/ScriptModuleLoader.h:
>+        * bindings/js/ScriptSourceCode.h:
>+        (WebCore::ScriptSourceCode::ScriptSourceCode):
>+        * dom/CurrentScriptIncrementer.h:
>+        (WebCore::CurrentScriptIncrementer::CurrentScriptIncrementer):
>+        * dom/LoadableClassicScript.cpp:
>+        (WebCore::LoadableClassicScript::error):
>+        (WebCore::LoadableClassicScript::execute):
>+        (WebCore::LoadableClassicScript::wasErrored): Deleted.
>+        * dom/LoadableClassicScript.h:
>+        * dom/LoadableModuleScript.cpp: Copied from Source/WebCore/dom/LoadableScript.h.
>+        This is the derived class from LoadableScript. It is used for the script module graphs.
>+        (WebCore::LoadableModuleScript::create):
>+        (WebCore::LoadableModuleScript::LoadableModuleScript):
>+        (WebCore::LoadableModuleScript::~LoadableModuleScript):
>+        (WebCore::LoadableModuleScript::isLoaded):
>+        (WebCore::LoadableModuleScript::error):
>+        (WebCore::LoadableModuleScript::wasCanceled):
>+        (WebCore::LoadableModuleScript::notifyFinished):
>+        (WebCore::LoadableModuleScript::execute):
>+        * dom/LoadableModuleScript.h: Copied from Source/WebCore/dom/LoadableScript.h.
>+        (isType):
>+        * dom/LoadableScript.h:
>+        (WebCore::LoadableScript::isModuleScript):
>+        (WebCore::LoadableScript::isModuleGraph): Deleted.
>+        * dom/PendingScript.cpp:
>+        (WebCore::PendingScript::error):
>+        (WebCore::PendingScript::wasErrored): Deleted.
>+        * dom/PendingScript.h:
>+        * dom/ScriptElement.cpp:
>+        (WebCore::ScriptElement::ScriptElement):
>+        (WebCore::ScriptElement::determineScriptType):
>+        (WebCore::ScriptElement::prepareScript):
>+        prepareScript is aligned to whatwg spec: the last sequence to setup flags has one-on-one correspondence to
>+        the spec now. And prepareScript recognizes the type="module" case and call the requestModuleScript to setup
>+        the CachedModuleScript.
>+        (WebCore::ScriptElement::requestClassicScript):
>+        (WebCore::ScriptElement::requestModuleScript):
>+        We use the nonce and crossorigin attributes at the time of preparing the script tag. To do so, we store the
>+        above values in CachedModuleScript.
>+        (WebCore::ScriptElement::requestScriptWithCacheForModuleScript):
>+        The module loader will construct the fetching request by calling this function. This should be here since we
>+        would like to set this Element to the initiator of the request. And nonce and crossorigin attributes of this
>+        script tag will be used.
>+        (WebCore::ScriptElement::requestScriptWithCache):
>+        (WebCore::ScriptElement::executeScript):
>+        (WebCore::ScriptElement::executeModuleScript):
>+        The entry point to execute the module graph. Since the module graph is beyond the multiple CachedScript code,
>+        we have the different entry point from ScriptElement::executeScript.
>+        (WebCore::ScriptElement::executeScriptAndDispatchEvent):
>+        (WebCore::ScriptElement::executeScriptForScriptRunner):
>+        * dom/ScriptElement.h:
>+        (WebCore::ScriptElement::scriptType):
>+        * html/parser/CSSPreloadScanner.cpp:
>+        (WebCore::CSSPreloadScanner::emitRule):
>+        * html/parser/HTMLPreloadScanner.cpp:
>+        (WebCore::TokenPreloadScanner::StartTagScanner::createPreloadRequest):
>+        According to the spec, the module tag ignores the "charset" attribute as the same to the worker's
>+        importScript. But WebKit supports the "charset" for importScript intentionally. So to be consistent,
>+        even for the module tags, we handle the "charset" attribute. We explicitly note about it in the preloader.
>+        (WebCore::TokenPreloadScanner::StartTagScanner::processAttribute):
>+        * html/parser/HTMLResourcePreloader.cpp:
>+        (WebCore::PreloadRequest::resourceRequest):
>+        * html/parser/HTMLResourcePreloader.h:
>+        (WebCore::PreloadRequest::PreloadRequest):
>+        * html/parser/HTMLScriptRunner.h:
>+        * loader/cache/CachedResourceRequest.cpp:
>+        (WebCore::CachedResourceRequest::setAsPotentiallyCrossOriginImpl):
>+        (WebCore::CachedResourceRequest::setAsPotentiallyCrossOrigin):
>+        (WebCore::CachedResourceRequest::setAsPotentiallyCrossOriginForModuleScript):
>+        * loader/cache/CachedResourceRequest.h:
>+        * xml/parser/XMLDocumentParser.cpp:
>+        (WebCore::XMLDocumentParser::notifyFinished):
>+
> 2016-11-14  Joseph Pecoraro  <pecoraro@apple.com>
> 
>         Web Inspector: Worker debugging should pause all targets and view call frames in all targets
>diff --git a/Source/WebCore/CMakeLists.txt b/Source/WebCore/CMakeLists.txt
>index 8aa5e41ae0c61ec2c9231737de3eaa4eea1c41b8..d5cb12b3d2ef60d52023e6b06c768b9ed007d21e 100644
>--- a/Source/WebCore/CMakeLists.txt
>+++ b/Source/WebCore/CMakeLists.txt
>@@ -1068,6 +1068,8 @@ set(WebCore_SOURCES
>     bindings/generic/RuntimeEnabledFeatures.cpp
> 
>     bindings/js/ArrayValue.cpp
>+    bindings/js/CachedModuleScript.cpp
>+    bindings/js/CachedModuleScriptLoader.cpp
>     bindings/js/CallbackFunction.cpp
>     bindings/js/DOMWrapperWorld.cpp
>     bindings/js/Dictionary.cpp
>@@ -1465,6 +1467,7 @@ set(WebCore_SOURCES
>     dom/KeyboardEvent.cpp
>     dom/LiveNodeList.cpp
>     dom/LoadableClassicScript.cpp
>+    dom/LoadableModuleScript.cpp
>     dom/LoadableScript.cpp
>     dom/MessageChannel.cpp
>     dom/MessageEvent.cpp
>diff --git a/Source/WebCore/WebCore.xcodeproj/project.pbxproj b/Source/WebCore/WebCore.xcodeproj/project.pbxproj
>index b65e3728b5ba38c8c08796d0d7dc009f9e7c710c..0c811120c385ff5abba21fcf5899e3dde3aeec2a 100644
>--- a/Source/WebCore/WebCore.xcodeproj/project.pbxproj
>+++ b/Source/WebCore/WebCore.xcodeproj/project.pbxproj
>@@ -6258,6 +6258,14 @@
> 		E1FF57A60F01256B00891EBB /* ThreadGlobalData.cpp in Sources */ = {isa = PBXBuildFile; fileRef = E1FF57A50F01256B00891EBB /* ThreadGlobalData.cpp */; };
> 		E1FF8F6C180DB5BE00132674 /* CryptoAlgorithmRegistry.cpp in Sources */ = {isa = PBXBuildFile; fileRef = E1FF8F6A180DB5BE00132674 /* CryptoAlgorithmRegistry.cpp */; };
> 		E1FF8F6D180DB5BE00132674 /* CryptoAlgorithmRegistry.h in Headers */ = {isa = PBXBuildFile; fileRef = E1FF8F6B180DB5BE00132674 /* CryptoAlgorithmRegistry.h */; };
>+		E307DECC1D81E4B300141CAF /* CachedModuleScript.cpp in Sources */ = {isa = PBXBuildFile; fileRef = E307DEC91D81E46E00141CAF /* CachedModuleScript.cpp */; };
>+		E307DECD1D81E4B600141CAF /* CachedModuleScript.h in Headers */ = {isa = PBXBuildFile; fileRef = E307DECA1D81E46E00141CAF /* CachedModuleScript.h */; settings = {ATTRIBUTES = (Private, ); }; };
>+		E307DECE1D81E4BA00141CAF /* CachedModuleScriptClient.h in Headers */ = {isa = PBXBuildFile; fileRef = E307DECB1D81E49500141CAF /* CachedModuleScriptClient.h */; settings = {ATTRIBUTES = (Private, ); }; };
>+		E307DECF1D81E4C300141CAF /* CachedModuleScriptLoader.cpp in Sources */ = {isa = PBXBuildFile; fileRef = E307DEC61D81E44800141CAF /* CachedModuleScriptLoader.cpp */; };
>+		E307DED01D81E4C700141CAF /* CachedModuleScriptLoader.h in Headers */ = {isa = PBXBuildFile; fileRef = E307DEC71D81E44800141CAF /* CachedModuleScriptLoader.h */; settings = {ATTRIBUTES = (Private, ); }; };
>+		E307DED11D81E4CB00141CAF /* CachedModuleScriptLoaderClient.h in Headers */ = {isa = PBXBuildFile; fileRef = E307DEC81D81E44800141CAF /* CachedModuleScriptLoaderClient.h */; settings = {ATTRIBUTES = (Private, ); }; };
>+		E307DED41D81E4F000141CAF /* LoadableModuleScript.cpp in Sources */ = {isa = PBXBuildFile; fileRef = E307DED21D81E4ED00141CAF /* LoadableModuleScript.cpp */; };
>+		E307DED51D81E4F200141CAF /* LoadableModuleScript.h in Headers */ = {isa = PBXBuildFile; fileRef = E307DED31D81E4ED00141CAF /* LoadableModuleScript.h */; settings = {ATTRIBUTES = (Private, ); }; };
> 		E3150EA61DA7219000194012 /* JSNodeDOMJIT.cpp in Sources */ = {isa = PBXBuildFile; fileRef = E3AFA9641DA6E908002861BD /* JSNodeDOMJIT.cpp */; };
> 		E3150EA71DA7219300194012 /* DOMJITHelpers.h in Headers */ = {isa = PBXBuildFile; fileRef = E3150EA51DA7218D00194012 /* DOMJITHelpers.h */; };
> 		E318039D1DC40099009932C2 /* JSDynamicDowncast.h in Headers */ = {isa = PBXBuildFile; fileRef = E3A5872E1DC3F52600F607A6 /* JSDynamicDowncast.h */; settings = {ATTRIBUTES = (Private, ); }; };
>@@ -14201,6 +14209,14 @@
> 		E1FF8F661807460800132674 /* JSWebKitSubtleCryptoCustom.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = JSWebKitSubtleCryptoCustom.cpp; sourceTree = "<group>"; };
> 		E1FF8F6A180DB5BE00132674 /* CryptoAlgorithmRegistry.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = CryptoAlgorithmRegistry.cpp; sourceTree = "<group>"; };
> 		E1FF8F6B180DB5BE00132674 /* CryptoAlgorithmRegistry.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = CryptoAlgorithmRegistry.h; sourceTree = "<group>"; };
>+		E307DEC61D81E44800141CAF /* CachedModuleScriptLoader.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = CachedModuleScriptLoader.cpp; sourceTree = "<group>"; };
>+		E307DEC71D81E44800141CAF /* CachedModuleScriptLoader.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = CachedModuleScriptLoader.h; sourceTree = "<group>"; };
>+		E307DEC81D81E44800141CAF /* CachedModuleScriptLoaderClient.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = CachedModuleScriptLoaderClient.h; sourceTree = "<group>"; };
>+		E307DEC91D81E46E00141CAF /* CachedModuleScript.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = CachedModuleScript.cpp; sourceTree = "<group>"; };
>+		E307DECA1D81E46E00141CAF /* CachedModuleScript.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = CachedModuleScript.h; sourceTree = "<group>"; };
>+		E307DECB1D81E49500141CAF /* CachedModuleScriptClient.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = CachedModuleScriptClient.h; sourceTree = "<group>"; };
>+		E307DED21D81E4ED00141CAF /* LoadableModuleScript.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = LoadableModuleScript.cpp; sourceTree = "<group>"; };
>+		E307DED31D81E4ED00141CAF /* LoadableModuleScript.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = LoadableModuleScript.h; sourceTree = "<group>"; };
> 		E3150EA51DA7218D00194012 /* DOMJITHelpers.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = DOMJITHelpers.h; sourceTree = "<group>"; };
> 		E334825E1DC93AA0009C9544 /* DOMJITAbstractHeapRepository.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = DOMJITAbstractHeapRepository.h; sourceTree = "<group>"; };
> 		E34EE49F1DC2D57500EAA9D3 /* JSEventCustom.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = JSEventCustom.h; sourceTree = "<group>"; };
>@@ -21781,6 +21797,9 @@
> 				49B3760A15C6C6840059131D /* ArrayValue.cpp */,
> 				49B3760B15C6C6840059131D /* ArrayValue.h */,
> 				2DFA488E1DB541C200362B99 /* BufferSource.h */,
>+				E307DEC61D81E44800141CAF /* CachedModuleScriptLoader.cpp */,
>+				E307DEC71D81E44800141CAF /* CachedModuleScriptLoader.h */,
>+				E307DEC81D81E44800141CAF /* CachedModuleScriptLoaderClient.h */,
> 				BCD533630ED6848900887468 /* CachedScriptSourceProvider.h */,
> 				93F8B3060A300FEA00F61AB8 /* CodeGeneratorJS.pm */,
> 				312D67B01535691F00563D0D /* Dictionary.cpp */,
>@@ -21861,6 +21880,9 @@
> 				41F066E20F64BCF600A07EAC /* ScriptGlobalObject.h */,
> 				E38838941BAD145F00D62EE3 /* ScriptModuleLoader.cpp */,
> 				E38838951BAD145F00D62EE3 /* ScriptModuleLoader.h */,
>+				E307DEC91D81E46E00141CAF /* CachedModuleScript.cpp */,
>+				E307DECA1D81E46E00141CAF /* CachedModuleScript.h */,
>+				E307DECB1D81E49500141CAF /* CachedModuleScriptClient.h */,
> 				934CC1090EDB223900A658F2 /* ScriptSourceCode.h */,
> 				4127D5360F8AAB1D00E424F5 /* ScriptState.cpp */,
> 				41C760B00EDE03D300C1655F /* ScriptState.h */,
>@@ -24003,6 +24025,8 @@
> 				E3B2F0E41D7F35EC00B0C9D1 /* LoadableClassicScript.h */,
> 				E3B2F0E91D7F3D3C00B0C9D1 /* LoadableScript.cpp */,
> 				E3B2F0E71D7F35EC00B0C9D1 /* LoadableScript.h */,
>+				E307DED21D81E4ED00141CAF /* LoadableModuleScript.cpp */,
>+				E307DED31D81E4ED00141CAF /* LoadableModuleScript.h */,
> 				E3B2F0E81D7F35EC00B0C9D1 /* LoadableScriptClient.h */,
> 				BC9A6144146859D9006057FD /* make_dom_exceptions.pl */,
> 				BC9A6145146859D9006057FD /* make_event_factory.pl */,
>@@ -24910,6 +24934,7 @@
> 				BCC065810F3CE1B700CD2D87 /* ClientRectList.h in Headers */,
> 				7C3A91E61C963B8800D1A7E3 /* ClipboardAccessPolicy.h in Headers */,
> 				85031B400A44EFC700F992E0 /* ClipboardEvent.h in Headers */,
>+				E307DED01D81E4C700141CAF /* CachedModuleScriptLoader.h in Headers */,
> 				FB92DF4B15FED08700994433 /* ClipPathOperation.h in Headers */,
> 				580371621A66F00A00BAF519 /* ClipRect.h in Headers */,
> 				97AABD1314FA09D5007457AE /* CloseEvent.h in Headers */,
>@@ -25724,6 +25749,7 @@
> 				514129991C6976900059E714 /* IDBRequestCompletionEvent.h in Headers */,
> 				510A58FA1BACC7F200C19282 /* IDBRequestData.h in Headers */,
> 				5145B10A1BC48E2E00E86219 /* IDBResourceIdentifier.h in Headers */,
>+				E307DED11D81E4CB00141CAF /* CachedModuleScriptLoaderClient.h in Headers */,
> 				51D7236D1BB6174900478CA3 /* IDBResultData.h in Headers */,
> 				511EC1281C50AACA0032F983 /* IDBSerialization.h in Headers */,
> 				5185FCBB1BB4CBF80012898F /* IDBServer.h in Headers */,
>@@ -25973,6 +25999,7 @@
> 				7694563D1214D97C0007CBAE /* JSDOMTokenList.h in Headers */,
> 				2E37E00612DBC5A400A6B233 /* JSDOMURL.h in Headers */,
> 				BC6932740D7E293900AE44D1 /* JSDOMWindowBase.h in Headers */,
>+				E307DECE1D81E4BA00141CAF /* CachedModuleScriptClient.h in Headers */,
> 				652FBBBC0DE27CB60001D386 /* JSDOMWindowCustom.h in Headers */,
> 				460CBF361D4BCD0E0092E88E /* JSDOMWindowProperties.h in Headers */,
> 				BCBFB53D0DCD29CF0019B3E5 /* JSDOMWindowShell.h in Headers */,
>@@ -26853,6 +26880,7 @@
> 				A5F8CD121D18F32E00AC0E53 /* PageHeapAgent.h in Headers */,
> 				2D5C9D0019C7B52E00B3C5C1 /* PageOverlay.h in Headers */,
> 				2D5C9D0219C7B52E00B3C5C1 /* PageOverlayController.h in Headers */,
>+				E307DED51D81E4F200141CAF /* LoadableModuleScript.h in Headers */,
> 				FBDB61A116D6037E00BB3394 /* PageRuleCollector.h in Headers */,
> 				F3820895147D35F90010BC06 /* PageRuntimeAgent.h in Headers */,
> 				A5F36D3B18F758720054C024 /* PageScriptDebugServer.h in Headers */,
>@@ -27494,6 +27522,7 @@
> 				A80E6DFC0A199067007FB8C5 /* StyleProperties.h in Headers */,
> 				E1B25107152A0BB00069B779 /* StylePropertyShorthand.h in Headers */,
> 				83C05A5B1A686212007E5DEA /* StylePropertyShorthandFunctions.h in Headers */,
>+				E307DECD1D81E4B600141CAF /* CachedModuleScript.h in Headers */,
> 				BC2272E40E82EE9B00E7F975 /* StyleRareInheritedData.h in Headers */,
> 				BC2272BD0E82EAAE00E7F975 /* StyleRareNonInheritedData.h in Headers */,
> 				BC2272870E82E70700E7F975 /* StyleReflection.h in Headers */,
>@@ -28940,6 +28969,7 @@
> 				BC1790BD1BBB36A80006D13E /* CSSVariableDependentValue.cpp in Sources */,
> 				9444CBD91D88483A0073A074 /* CSSVariableParser.cpp in Sources */,
> 				9444CBE91D8861CA0073A074 /* CSSVariableReferenceValue.cpp in Sources */,
>+				E307DECF1D81E4C300141CAF /* CachedModuleScriptLoader.cpp in Sources */,
> 				BC1790C01BBF2C430006D13E /* CSSVariableValue.cpp in Sources */,
> 				E11AF15111B9A1A300805103 /* Cursor.cpp in Sources */,
> 				265541521489B233000DFC5D /* CursorIOS.cpp in Sources */,
>@@ -29441,6 +29471,7 @@
> 				5160712E1BD8307800DBC4F2 /* IDBObjectStoreInfo.cpp in Sources */,
> 				5185FCA31BB4C4E80012898F /* IDBOpenDBRequest.cpp in Sources */,
> 				5185FCA81BB4C4E80012898F /* IDBRequest.cpp in Sources */,
>+				E307DECC1D81E4B300141CAF /* CachedModuleScript.cpp in Sources */,
> 				514129981C6976900059E714 /* IDBRequestCompletionEvent.cpp in Sources */,
> 				510A58F91BACC7F200C19282 /* IDBRequestData.cpp in Sources */,
> 				5145B1091BC48E2E00E86219 /* IDBResourceIdentifier.cpp in Sources */,
>@@ -30084,6 +30115,7 @@
> 				B222F69C0AB771B80022EFAD /* JSSVGElement.cpp in Sources */,
> 				8542A79A0AE5C94400DF58DF /* JSSVGElementWrapperFactory.cpp in Sources */,
> 				B2FA3D680AB75A6F000E5AC4 /* JSSVGEllipseElement.cpp in Sources */,
>+				E307DED41D81E4F000141CAF /* LoadableModuleScript.cpp in Sources */,
> 				B266CD4D0C3AEC6500EB08D2 /* JSSVGException.cpp in Sources */,
> 				B2FA3D6A0AB75A6F000E5AC4 /* JSSVGFEBlendElement.cpp in Sources */,
> 				B2FA3D6C0AB75A6F000E5AC4 /* JSSVGFEColorMatrixElement.cpp in Sources */,
>diff --git a/Source/WebCore/bindings/js/CachedModuleScript.cpp b/Source/WebCore/bindings/js/CachedModuleScript.cpp
>new file mode 100644
>index 0000000000000000000000000000000000000000..4bef2a8aa838d7617333e30fd26d9abd1b7eed87
>--- /dev/null
>+++ b/Source/WebCore/bindings/js/CachedModuleScript.cpp
>@@ -0,0 +1,110 @@
>+/*
>+ * Copyright (C) 2015-2016 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
>+ *    documentation and/or other materials provided with the distribution.
>+ *
>+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
>+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
>+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
>+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
>+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
>+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
>+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
>+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
>+ * CONTRACT, STRICT LIABILITY, OR TORT (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 "config.h"
>+#include "CachedModuleScript.h"
>+
>+#include "CachedModuleScriptClient.h"
>+#include "DOMWrapperWorld.h"
>+#include "Document.h"
>+#include "Element.h"
>+#include "ExceptionCode.h"
>+#include "Frame.h"
>+#include "ScriptController.h"
>+#include "ScriptElement.h"
>+#include "ScriptModuleLoader.h"
>+#include "ScriptRunner.h"
>+#include "ScriptSourceCode.h"
>+
>+namespace WebCore {
>+
>+Ref<CachedModuleScript> CachedModuleScript::create(const String& nonce, const String& crossOriginMode)
>+{
>+    return adoptRef(*new CachedModuleScript(nonce, crossOriginMode));
>+}
>+
>+CachedModuleScript::CachedModuleScript(const String& nonce, const String& crossOriginMode)
>+    : m_nonce(nonce)
>+    , m_crossOriginMode(crossOriginMode)
>+{
>+}
>+
>+void CachedModuleScript::load(Element& initiator, const URL& rootURL)
>+{
>+    if (auto* frame = initiator.document().frame())
>+        frame->script().loadModuleScript(*this, rootURL.string(), initiator);
>+}
>+
>+void CachedModuleScript::load(Element& initiator, const ScriptSourceCode& sourceCode)
>+{
>+    if (auto* frame = initiator.document().frame())
>+        frame->script().loadModuleScript(*this, sourceCode, initiator);
>+}
>+
>+void CachedModuleScript::notifyLoadCompleted(UniquedStringImpl& moduleKey)
>+{
>+    m_moduleKey = &moduleKey;
>+    notifyClientFinished();
>+}
>+
>+void CachedModuleScript::notifyLoadFailed(LoadableScript::Error&& error)
>+{
>+    m_error = WTFMove(error);
>+    notifyClientFinished();
>+}
>+
>+void CachedModuleScript::notifyLoadWasCanceled()
>+{
>+    m_wasCanceled = true;
>+    notifyClientFinished();
>+}
>+
>+void CachedModuleScript::notifyClientFinished()
>+{
>+    m_isLoaded = true;
>+
>+    Ref<CachedModuleScript> protectedThis(*this);
>+
>+    Vector<CachedModuleScriptClient*> clients;
>+    copyToVector(m_clients, clients);
>+    for (auto& client : clients)
>+        client->notifyFinished(*this);
>+}
>+
>+void CachedModuleScript::addClient(CachedModuleScriptClient& client)
>+{
>+    m_clients.add(&client);
>+    if (!isLoaded())
>+        return;
>+    Ref<CachedModuleScript> protectedThis(*this);
>+    client.notifyFinished(*this);
>+}
>+
>+void CachedModuleScript::removeClient(CachedModuleScriptClient& client)
>+{
>+    m_clients.remove(&client);
>+}
>+
>+}
>diff --git a/Source/WebCore/bindings/js/CachedModuleScript.h b/Source/WebCore/bindings/js/CachedModuleScript.h
>new file mode 100644
>index 0000000000000000000000000000000000000000..98889d5ef302dd06de4840bd3457dd476128c128
>--- /dev/null
>+++ b/Source/WebCore/bindings/js/CachedModuleScript.h
>@@ -0,0 +1,77 @@
>+/*
>+ * Copyright (C) 2015, 2016 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
>+ *    documentation and/or other materials provided with the distribution.
>+ *
>+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
>+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
>+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
>+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
>+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
>+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
>+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
>+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
>+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
>+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
>+ * THE POSSIBILITY OF SUCH DAMAGE.
>+ */
>+
>+#pragma once
>+
>+#include "CachedModuleScriptLoader.h"
>+#include "LoadableScript.h"
>+#include <runtime/JSInternalPromise.h>
>+
>+namespace WebCore {
>+
>+class CachedModuleScriptClient;
>+class Element;
>+class ScriptSourceCode;
>+
>+class CachedModuleScript : public RefCounted<CachedModuleScript> {
>+public:
>+    UniquedStringImpl* moduleKey() { return m_moduleKey.get(); }
>+
>+    void evaluate(Element&);
>+
>+    void notifyLoadCompleted(UniquedStringImpl& moduleKey);
>+    void notifyLoadFailed(LoadableScript::Error&&);
>+    void notifyLoadWasCanceled();
>+
>+    const Optional<LoadableScript::Error>& error() const { return m_error; }
>+    bool wasCanceled() const { return m_wasCanceled; }
>+    bool isLoaded() const { return m_isLoaded; }
>+
>+    void addClient(CachedModuleScriptClient&);
>+    void removeClient(CachedModuleScriptClient&);
>+
>+    static Ref<CachedModuleScript> create(const String& nonce, const String& crossOriginMode);
>+
>+    void load(Element& initiator, const URL& rootURL);
>+    void load(Element& initiator, const ScriptSourceCode&);
>+
>+    const String& nonce() const { return m_nonce; }
>+    const String& crossOriginMode() const { return m_crossOriginMode; }
>+
>+private:
>+    CachedModuleScript(const String& nonce, const String& crossOriginMode);
>+
>+    void notifyClientFinished();
>+
>+    RefPtr<UniquedStringImpl> m_moduleKey;
>+    HashCountedSet<CachedModuleScriptClient*> m_clients;
>+    String m_nonce;
>+    String m_crossOriginMode;
>+    Optional<LoadableScript::Error> m_error;
>+    bool m_wasCanceled { false };
>+    bool m_isLoaded { false };
>+};
>+
>+} // namespace WebCore
>diff --git a/Source/WebCore/bindings/js/CachedModuleScriptClient.h b/Source/WebCore/bindings/js/CachedModuleScriptClient.h
>new file mode 100644
>index 0000000000000000000000000000000000000000..3534516dd9488edcbc5ead98ba14f05c0965374b
>--- /dev/null
>+++ b/Source/WebCore/bindings/js/CachedModuleScriptClient.h
>@@ -0,0 +1,39 @@
>+/*
>+ * Copyright (C) 2016 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
>+ *    documentation and/or other materials provided with the distribution.
>+ *
>+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
>+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
>+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
>+ * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE INC. OR
>+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
>+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
>+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
>+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
>+ * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
>+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
>+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
>+ */
>+
>+#pragma once
>+
>+namespace WebCore {
>+
>+class CachedModuleScript;
>+
>+class CachedModuleScriptClient {
>+public:
>+    virtual ~CachedModuleScriptClient() { }
>+
>+    virtual void notifyFinished(CachedModuleScript&) = 0;
>+};
>+
>+}
>diff --git a/Source/WebCore/bindings/js/CachedModuleScriptLoader.cpp b/Source/WebCore/bindings/js/CachedModuleScriptLoader.cpp
>new file mode 100644
>index 0000000000000000000000000000000000000000..1f964d632dfafbdb1ec4da5fa1aaaf3396aeed14
>--- /dev/null
>+++ b/Source/WebCore/bindings/js/CachedModuleScriptLoader.cpp
>@@ -0,0 +1,90 @@
>+/*
>+ * Copyright (C) 2015-2016 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
>+ *    documentation and/or other materials provided with the distribution.
>+ *
>+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
>+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
>+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
>+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
>+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
>+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
>+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
>+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
>+ * CONTRACT, STRICT LIABILITY, OR TORT (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 "config.h"
>+#include "CachedModuleScriptLoader.h"
>+
>+#include "CachedResourceLoader.h"
>+#include "CachedScript.h"
>+#include "DOMWrapperWorld.h"
>+#include "Frame.h"
>+#include "JSDOMBinding.h"
>+#include "ResourceLoaderOptions.h"
>+#include "ScriptController.h"
>+#include "ScriptElement.h"
>+#include "ScriptModuleLoader.h"
>+#include "ScriptSourceCode.h"
>+
>+namespace WebCore {
>+
>+Ref<CachedModuleScriptLoader> CachedModuleScriptLoader::create(CachedModuleScriptLoaderClient& client, DeferredPromise& promise)
>+{
>+    return adoptRef(*new CachedModuleScriptLoader(client, promise));
>+}
>+
>+CachedModuleScriptLoader::CachedModuleScriptLoader(CachedModuleScriptLoaderClient& client, DeferredPromise& promise)
>+    : m_client(&client)
>+    , m_promise(&promise)
>+{
>+}
>+
>+CachedModuleScriptLoader::~CachedModuleScriptLoader()
>+{
>+    if (m_cachedScript) {
>+        m_cachedScript->removeClient(*this);
>+        m_cachedScript = nullptr;
>+    }
>+}
>+
>+bool CachedModuleScriptLoader::load(ScriptElement& scriptElement, const URL& sourceURL)
>+{
>+    ASSERT(!m_cachedScript);
>+    m_cachedScript = scriptElement.requestScriptWithCacheForModuleScript(sourceURL);
>+    if (!m_cachedScript)
>+        return false;
>+
>+    // If the content is already cached, this immediately calls notifyFinished.
>+    m_cachedScript->addClient(*this);
>+    return true;
>+}
>+
>+void CachedModuleScriptLoader::notifyFinished(CachedResource& resource)
>+{
>+    ASSERT_UNUSED(resource, &resource == m_cachedScript);
>+    ASSERT(m_cachedScript);
>+    ASSERT(m_promise);
>+
>+    Ref<CachedModuleScriptLoader> protectedThis(*this);
>+    if (m_client)
>+        m_client->notifyFinished(*this, WTFMove(m_promise));
>+
>+    // A CachedResourceHandle alone does not prevent the underlying CachedResource
>+    // from purging its data buffer. To keep the underlying CachedResource during
>+    // processing, we remove the client after calling client's notifyFinished.
>+    m_cachedScript->removeClient(*this);
>+    m_cachedScript = nullptr;
>+}
>+
>+}
>diff --git a/Source/WebCore/bindings/js/CachedModuleScriptLoader.h b/Source/WebCore/bindings/js/CachedModuleScriptLoader.h
>new file mode 100644
>index 0000000000000000000000000000000000000000..3a04d5d5ef1fe409a89988d648fcb1c1c1343161
>--- /dev/null
>+++ b/Source/WebCore/bindings/js/CachedModuleScriptLoader.h
>@@ -0,0 +1,69 @@
>+/*
>+ * Copyright (C) 2015, 2016 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
>+ *    documentation and/or other materials provided with the distribution.
>+ *
>+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
>+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
>+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
>+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
>+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
>+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
>+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
>+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
>+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
>+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
>+ * THE POSSIBILITY OF SUCH DAMAGE.
>+ */
>+
>+#pragma once
>+
>+#include "CachedResourceClient.h"
>+#include "CachedResourceHandle.h"
>+#include "JSDOMPromise.h"
>+#include <wtf/Ref.h>
>+#include <wtf/RefCounted.h>
>+
>+namespace WebCore {
>+
>+class CachedModuleScriptLoaderClient;
>+class CachedScript;
>+class DeferredPromise;
>+class JSDOMGlobalObject;
>+class ScriptElement;
>+class URL;
>+
>+class CachedModuleScriptLoader final : public RefCounted<CachedModuleScriptLoader>, private CachedResourceClient {
>+public:
>+    static Ref<CachedModuleScriptLoader> create(CachedModuleScriptLoaderClient&, DeferredPromise&);
>+
>+    virtual ~CachedModuleScriptLoader();
>+
>+    bool load(ScriptElement&, const URL& sourceURL);
>+
>+    CachedScript* cachedScript() { return m_cachedScript.get(); }
>+
>+    void clearClient()
>+    {
>+        ASSERT(m_client);
>+        m_client = nullptr;
>+    }
>+
>+private:
>+    CachedModuleScriptLoader(CachedModuleScriptLoaderClient&, DeferredPromise&);
>+
>+    void notifyFinished(CachedResource&) final;
>+
>+    CachedModuleScriptLoaderClient* m_client { nullptr };
>+    RefPtr<DeferredPromise> m_promise;
>+    CachedResourceHandle<CachedScript> m_cachedScript;
>+};
>+
>+} // namespace WebCore
>diff --git a/Source/WebCore/bindings/js/CachedModuleScriptLoaderClient.h b/Source/WebCore/bindings/js/CachedModuleScriptLoaderClient.h
>new file mode 100644
>index 0000000000000000000000000000000000000000..6ccdbccca77a9edd6ccd1ce0fb33a07c0169420c
>--- /dev/null
>+++ b/Source/WebCore/bindings/js/CachedModuleScriptLoaderClient.h
>@@ -0,0 +1,41 @@
>+/*
>+ * Copyright (C) 2016 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
>+ *    documentation and/or other materials provided with the distribution.
>+ *
>+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
>+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
>+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
>+ * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE INC. OR
>+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
>+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
>+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
>+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
>+ * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
>+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
>+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
>+ */
>+
>+#pragma once
>+
>+#include "JSDOMPromise.h"
>+
>+namespace WebCore {
>+
>+class CachedModuleScriptLoader;
>+
>+class CachedModuleScriptLoaderClient {
>+public:
>+    virtual ~CachedModuleScriptLoaderClient() { }
>+
>+    virtual void notifyFinished(CachedModuleScriptLoader&, RefPtr<DeferredPromise>) = 0;
>+};
>+
>+}
>diff --git a/Source/WebCore/bindings/js/CachedScriptSourceProvider.h b/Source/WebCore/bindings/js/CachedScriptSourceProvider.h
>index bf8db6107882d8c12510d2d67dd0bcf28ddb5df6..5deb3950cd1063901914d92e585ff7c428f41dd6 100644
>--- a/Source/WebCore/bindings/js/CachedScriptSourceProvider.h
>+++ b/Source/WebCore/bindings/js/CachedScriptSourceProvider.h
>@@ -36,7 +36,7 @@ namespace WebCore {
> class CachedScriptSourceProvider : public JSC::SourceProvider, public CachedResourceClient {
>     WTF_MAKE_FAST_ALLOCATED;
> public:
>-    static Ref<CachedScriptSourceProvider> create(CachedScript* cachedScript) { return adoptRef(*new CachedScriptSourceProvider(cachedScript)); }
>+    static Ref<CachedScriptSourceProvider> create(CachedScript* cachedScript, JSC::SourceProviderSourceType sourceType) { return adoptRef(*new CachedScriptSourceProvider(cachedScript, sourceType)); }
> 
>     virtual ~CachedScriptSourceProvider()
>     {
>@@ -47,8 +47,8 @@ class CachedScriptSourceProvider : public JSC::SourceProvider, public CachedReso
>     StringView source() const override { return m_cachedScript->script(); }
> 
> private:
>-    CachedScriptSourceProvider(CachedScript* cachedScript)
>-        : SourceProvider(cachedScript->response().url(), TextPosition::minimumPosition(), JSC::SourceProviderSourceType::Program)
>+    CachedScriptSourceProvider(CachedScript* cachedScript, JSC::SourceProviderSourceType sourceType)
>+        : SourceProvider(cachedScript->response().url(), TextPosition::minimumPosition(), sourceType)
>         , m_cachedScript(cachedScript)
>     {
>         m_cachedScript->addClient(*this);
>@@ -59,7 +59,7 @@ class CachedScriptSourceProvider : public JSC::SourceProvider, public CachedReso
> 
> inline JSC::SourceCode makeSource(CachedScript* cachedScript)
> {
>-    return JSC::SourceCode(CachedScriptSourceProvider::create(cachedScript));
>+    return JSC::SourceCode(CachedScriptSourceProvider::create(cachedScript, JSC::SourceProviderSourceType::Program));
> }
> 
> } // namespace WebCore
>diff --git a/Source/WebCore/bindings/js/JSBindingsAllInOne.cpp b/Source/WebCore/bindings/js/JSBindingsAllInOne.cpp
>index b071212789c8acf75101156efaf5840468ff624b..c1ee21a58fd1978ddd39779cd7329d850fb6664e 100644
>--- a/Source/WebCore/bindings/js/JSBindingsAllInOne.cpp
>+++ b/Source/WebCore/bindings/js/JSBindingsAllInOne.cpp
>@@ -26,6 +26,8 @@
> // This all-in-one cpp file cuts down on template bloat to allow us to build our Windows release build.
> 
> #include "ArrayValue.cpp"
>+#include "CachedModuleScript.cpp"
>+#include "CachedModuleScriptLoader.cpp"
> #include "CallbackFunction.cpp"
> #include "DOMWrapperWorld.cpp"
> #include "Dictionary.cpp"
>diff --git a/Source/WebCore/bindings/js/JSDOMBinding.cpp b/Source/WebCore/bindings/js/JSDOMBinding.cpp
>index c445dea4fa54194065e4e03edcfb71c4aeef4dad..ad1119f2addbe3739407943012a1862e0bcff8b5 100644
>--- a/Source/WebCore/bindings/js/JSDOMBinding.cpp
>+++ b/Source/WebCore/bindings/js/JSDOMBinding.cpp
>@@ -156,6 +156,26 @@ void reportException(ExecState* exec, JSValue exceptionValue, CachedScript* cach
>     reportException(exec, exception, cachedScript);
> }
> 
>+String retrieveErrorMessage(ExecState& state, VM& vm, JSValue exception, CatchScope& catchScope)
>+{
>+    if (auto* exceptionBase = toExceptionBase(exception))
>+        return exceptionBase->toString();
>+
>+    // FIXME: <http://webkit.org/b/115087> Web Inspector: WebCore::reportException should not evaluate JavaScript handling exceptions
>+    // If this is a custom exception object, call toString on it to try and get a nice string representation for the exception.
>+    String errorMessage;
>+    if (auto* error = jsDynamicDowncast<ErrorInstance*>(exception))
>+        errorMessage = error->sanitizedToString(&state);
>+    else
>+        errorMessage = exception.toWTFString(&state);
>+
>+    // We need to clear any new exception that may be thrown in the toString() call above.
>+    // reportException() is not supposed to be making new exceptions.
>+    catchScope.clearException();
>+    vm.clearLastException();
>+    return errorMessage;
>+}
>+
> void reportException(ExecState* exec, JSC::Exception* exception, CachedScript* cachedScript, ExceptionDetails* exceptionDetails)
> {
>     VM& vm = exec->vm();
>@@ -186,24 +206,7 @@ void reportException(ExecState* exec, JSC::Exception* exception, CachedScript* c
>         exceptionSourceURL = callFrame->sourceURL();
>     }
> 
>-    String errorMessage;
>-    JSValue exceptionValue = exception->value();
>-    if (ExceptionBase* exceptionBase = toExceptionBase(exceptionValue))
>-        errorMessage = exceptionBase->toString();
>-    else {
>-        // FIXME: <http://webkit.org/b/115087> Web Inspector: WebCore::reportException should not evaluate JavaScript handling exceptions
>-        // If this is a custom exception object, call toString on it to try and get a nice string representation for the exception.
>-        if (ErrorInstance* error = jsDynamicDowncast<ErrorInstance*>(exceptionValue))
>-            errorMessage = error->sanitizedToString(exec);
>-        else
>-            errorMessage = exceptionValue.toString(exec)->value(exec);
>-
>-        // We need to clear any new exception that may be thrown in the toString() call above.
>-        // reportException() is not supposed to be making new exceptions.
>-        scope.clearException();
>-        vm.clearLastException();
>-    }
>-
>+    String errorMessage = retrieveErrorMessage(*exec, vm, exception->value(), scope);
>     ScriptExecutionContext* scriptExecutionContext = globalObject->scriptExecutionContext();
>     scriptExecutionContext->reportException(errorMessage, lineNumber, columnNumber, exceptionSourceURL, exception, callStack->size() ? callStack : nullptr, cachedScript);
> 
>diff --git a/Source/WebCore/bindings/js/JSDOMBinding.h b/Source/WebCore/bindings/js/JSDOMBinding.h
>index 9a4e036429374b6ae9510533a285a8dfa09e144a..9145fcc120bc52b46c0722cf778e34bf19c359dc 100644
>--- a/Source/WebCore/bindings/js/JSDOMBinding.h
>+++ b/Source/WebCore/bindings/js/JSDOMBinding.h
>@@ -182,6 +182,7 @@ void addImpureProperty(const AtomicString&);
> 
> const JSC::HashTable& getHashTableForGlobalData(JSC::VM&, const JSC::HashTable& staticTable);
> 
>+String retrieveErrorMessage(JSC::ExecState&, JSC::VM&, JSC::JSValue exception, JSC::CatchScope&);
> WEBCORE_EXPORT void reportException(JSC::ExecState*, JSC::JSValue exception, CachedScript* = nullptr);
> WEBCORE_EXPORT void reportException(JSC::ExecState*, JSC::Exception*, CachedScript* = nullptr, ExceptionDetails* = nullptr);
> void reportCurrentException(JSC::ExecState*);
>diff --git a/Source/WebCore/bindings/js/JSMainThreadExecState.h b/Source/WebCore/bindings/js/JSMainThreadExecState.h
>index 5122e3602500f51ef3ed7f1478a7f7992e80460c..c2766f086cc9d2872289d3b69b9fed727e236f1e 100644
>--- a/Source/WebCore/bindings/js/JSMainThreadExecState.h
>+++ b/Source/WebCore/bindings/js/JSMainThreadExecState.h
>@@ -93,25 +93,25 @@ class JSMainThreadExecState {
>         task.run(exec);
>     }
> 
>-    static JSC::JSInternalPromise* loadModule(JSC::ExecState* exec, const String& moduleName, JSC::JSValue initiator)
>+    static JSC::JSInternalPromise& loadModule(JSC::ExecState& state, const String& moduleName, JSC::JSValue initiator)
>     {
>-        JSMainThreadExecState currentState(exec);
>-        return JSC::loadModule(exec, moduleName, initiator);
>+        JSMainThreadExecState currentState(&state);
>+        return *JSC::loadModule(&state, moduleName, initiator);
>     }
> 
>-    static JSC::JSInternalPromise* loadModule(JSC::ExecState* exec, const JSC::SourceCode& sourceCode, JSC::JSValue initiator)
>+    static JSC::JSInternalPromise& loadModule(JSC::ExecState& state, const JSC::SourceCode& sourceCode, JSC::JSValue initiator)
>     {
>-        JSMainThreadExecState currentState(exec);
>-        return JSC::loadModule(exec, sourceCode, initiator);
>+        JSMainThreadExecState currentState(&state);
>+        return *JSC::loadModule(&state, sourceCode, initiator);
>     }
> 
>-    static JSC::JSValue linkAndEvaluateModule(JSC::ExecState* exec, const JSC::Identifier& moduleKey, JSC::JSValue initiator, NakedPtr<JSC::Exception>& returnedException)
>+    static JSC::JSValue linkAndEvaluateModule(JSC::ExecState& state, const JSC::Identifier& moduleKey, JSC::JSValue initiator, NakedPtr<JSC::Exception>& returnedException)
>     {
>-        JSC::VM& vm = exec->vm();
>+        JSC::VM& vm = state.vm();
>         auto scope = DECLARE_CATCH_SCOPE(vm);
>     
>-        JSMainThreadExecState currentState(exec);
>-        JSC::JSValue returnValue = JSC::linkAndEvaluateModule(exec, moduleKey, initiator);
>+        JSMainThreadExecState currentState(&state);
>+        auto returnValue = JSC::linkAndEvaluateModule(&state, moduleKey, initiator);
>         if (UNLIKELY(scope.exception())) {
>             returnedException = scope.exception();
>             scope.clearException();
>diff --git a/Source/WebCore/bindings/js/ScriptController.cpp b/Source/WebCore/bindings/js/ScriptController.cpp
>index 2873bc2b668a1dc126903c1e4e64d4f27583a4ba..e0685ed5ed23164df108a5475bfb9be59dce9ba2 100644
>--- a/Source/WebCore/bindings/js/ScriptController.cpp
>+++ b/Source/WebCore/bindings/js/ScriptController.cpp
>@@ -22,6 +22,7 @@
> #include "ScriptController.h"
> 
> #include "BridgeJSC.h"
>+#include "CachedModuleScript.h"
> #include "ContentSecurityPolicy.h"
> #include "DocumentLoader.h"
> #include "Event.h"
>@@ -41,6 +42,7 @@
> #include "PageConsoleClient.h"
> #include "PageGroup.h"
> #include "PluginViewBase.h"
>+#include "ScriptElement.h"
> #include "ScriptSourceCode.h"
> #include "ScriptableDocumentParser.h"
> #include "Settings.h"
>@@ -52,7 +54,12 @@
> #include <heap/StrongInlines.h>
> #include <inspector/ScriptCallStack.h>
> #include <runtime/InitializeThreading.h>
>+#include <runtime/JSFunction.h>
>+#include <runtime/JSInternalPromise.h>
> #include <runtime/JSLock.h>
>+#include <runtime/JSModuleRecord.h>
>+#include <runtime/JSNativeStdFunction.h>
>+#include <wtf/TemporaryChange.h>
> #include <wtf/Threading.h>
> #include <wtf/text/TextPosition.h>
> 
>@@ -154,7 +161,7 @@ JSValue ScriptController::evaluateInWorld(const ScriptSourceCode& sourceCode, DO
>     const String* savedSourceURL = m_sourceURL;
>     m_sourceURL = &sourceURL;
> 
>-    Ref<Frame> protect(m_frame);
>+    Ref<Frame> protector(m_frame);
> 
>     InspectorInstrumentationCookie cookie = InspectorInstrumentation::willEvaluateScript(m_frame, sourceURL, sourceCode.startLine());
> 
>@@ -178,6 +185,88 @@ JSValue ScriptController::evaluate(const ScriptSourceCode& sourceCode, Exception
>     return evaluateInWorld(sourceCode, mainThreadNormalWorld(), exceptionDetails);
> }
> 
>+void ScriptController::loadModuleScriptInWorld(CachedModuleScript& moduleScript, const String& moduleName, DOMWrapperWorld& world, Element& element)
>+{
>+    JSLockHolder lock(world.vm());
>+
>+    auto& shell = *windowShell(world);
>+    auto& state = *shell.window()->globalExec();
>+
>+    setupModuleScriptHandlers(moduleScript, JSMainThreadExecState::loadModule(state, moduleName, toJS(&state, shell.window(), &element)), world);
>+}
>+
>+void ScriptController::loadModuleScript(CachedModuleScript& moduleScript, const String& moduleName, Element& element)
>+{
>+    loadModuleScriptInWorld(moduleScript, moduleName, mainThreadNormalWorld(), element);
>+}
>+
>+void ScriptController::loadModuleScriptInWorld(CachedModuleScript& moduleScript, const ScriptSourceCode& sourceCode, DOMWrapperWorld& world, Element& element)
>+{
>+    JSLockHolder lock(world.vm());
>+
>+    auto& shell = *windowShell(world);
>+    auto& state = *shell.window()->globalExec();
>+
>+    setupModuleScriptHandlers(moduleScript, JSMainThreadExecState::loadModule(state, sourceCode.jsSourceCode(), toJS(&state, shell.window(), &element)), world);
>+}
>+
>+void ScriptController::loadModuleScript(CachedModuleScript& moduleScript, const ScriptSourceCode& sourceCode, Element& element)
>+{
>+    loadModuleScriptInWorld(moduleScript, sourceCode, mainThreadNormalWorld(), element);
>+}
>+
>+JSC::JSValue ScriptController::linkAndEvaluateModuleScriptInWorld(CachedModuleScript& moduleScript, DOMWrapperWorld& world, Element& element)
>+{
>+    JSLockHolder lock(world.vm());
>+
>+    auto& shell = *windowShell(world);
>+    auto& state = *shell.window()->globalExec();
>+
>+    // FIXME: Preventing Frame from being destroyed is essentially unnecessary.
>+    // https://bugs.webkit.org/show_bug.cgi?id=164763
>+    Ref<Frame> protector(m_frame);
>+
>+    NakedPtr<JSC::Exception> evaluationException;
>+    auto returnValue = JSMainThreadExecState::linkAndEvaluateModule(state, Identifier::fromUid(&state.vm(), moduleScript.moduleKey()), toJS(&state, shell.window(), &element), evaluationException);
>+    if (evaluationException) {
>+        // FIXME: Give a chance to dump the stack trace if the "crossorigin" attribute allows.
>+        // https://bugs.webkit.org/show_bug.cgi?id=164539
>+        reportException(&state, evaluationException, nullptr);
>+        return jsUndefined();
>+    }
>+    return returnValue;
>+}
>+
>+JSC::JSValue ScriptController::linkAndEvaluateModuleScript(CachedModuleScript& moduleScript, Element& element)
>+{
>+    return linkAndEvaluateModuleScriptInWorld(moduleScript, mainThreadNormalWorld(), element);
>+}
>+
>+JSC::JSValue ScriptController::evaluateModule(const URL& sourceURL, JSModuleRecord& moduleRecord, DOMWrapperWorld& world)
>+{
>+    JSLockHolder lock(world.vm());
>+
>+    const auto& jsSourceCode = moduleRecord.sourceCode();
>+
>+    auto& shell = *windowShell(world);
>+    auto& state = *shell.window()->globalExec();
>+    TemporaryChange<const String*> sourceURLScope(m_sourceURL, &sourceURL.string());
>+
>+    Ref<Frame> protector(m_frame);
>+
>+    auto cookie = InspectorInstrumentation::willEvaluateScript(m_frame, sourceURL, jsSourceCode.firstLine());
>+
>+    auto returnValue = moduleRecord.evaluate(&state);
>+    InspectorInstrumentation::didEvaluateScript(cookie, m_frame);
>+
>+    return returnValue;
>+}
>+
>+JSC::JSValue ScriptController::evaluateModule(const URL& sourceURL, JSModuleRecord& moduleRecord)
>+{
>+    return evaluateModule(sourceURL, moduleRecord, mainThreadNormalWorld());
>+}
>+
> Ref<DOMWrapperWorld> ScriptController::createWorld()
> {
>     return DOMWrapperWorld::create(JSDOMWindow::commonVM());
>@@ -258,6 +347,73 @@ JSDOMWindowShell* ScriptController::initScript(DOMWrapperWorld& world)
>     return &windowShell;
> }
> 
>+static Identifier jsValueToModuleKey(ExecState* exec, JSValue value)
>+{
>+    if (value.isSymbol())
>+        return Identifier::fromUid(jsCast<Symbol*>(value)->privateName());
>+    ASSERT(value.isString());
>+    return Identifier::fromString(exec, jsCast<JSString*>(value)->value(exec));
>+}
>+
>+enum class ErrorStatus {
>+    AlreadyReported,
>+    FetchingCanceled,
>+    ErrorThrown,
>+};
>+
>+void ScriptController::setupModuleScriptHandlers(CachedModuleScript& moduleScriptRef, JSInternalPromise& promise, DOMWrapperWorld& world)
>+{
>+    auto& shell = *windowShell(world);
>+    auto& state = *shell.window()->globalExec();
>+
>+    // It is not guaranteed that either fulfillHandler or rejectHandler is eventually called.
>+    // For example, if the page load is canceled, the DeferredPromise used in the module loader pipeline will stop executing JS code.
>+    // Thus the promise returned from this function could remain unresolved.
>+
>+    auto moduleLoaderAlreadyReportedErrorSymbol = m_moduleLoaderAlreadyReportedErrorSymbol;
>+    auto moduleLoaderFetchingIsCanceledSymbol = m_moduleLoaderFetchingIsCanceledSymbol;
>+
>+    RefPtr<CachedModuleScript> moduleScript(&moduleScriptRef);
>+
>+    auto& fulfillHandler = *JSNativeStdFunction::create(state.vm(), shell.window(), 1, String(), [moduleScript](ExecState* exec) {
>+        Identifier moduleKey = jsValueToModuleKey(exec, exec->argument(0));
>+        moduleScript->notifyLoadCompleted(*moduleKey.impl());
>+        return JSValue::encode(jsUndefined());
>+    });
>+
>+    auto& rejectHandler = *JSNativeStdFunction::create(state.vm(), shell.window(), 1, String(), [moduleScript, moduleLoaderAlreadyReportedErrorSymbol, moduleLoaderFetchingIsCanceledSymbol](ExecState* exec) {
>+        JSValue error = exec->argument(0);
>+        if (auto* symbol = jsDynamicCast<Symbol*>(error)) {
>+            if (symbol->privateName() == moduleLoaderAlreadyReportedErrorSymbol) {
>+                moduleScript->notifyLoadFailed(LoadableScript::Error {
>+                    LoadableScript::ErrorType::CachedScript,
>+                    Nullopt
>+                });
>+                return JSValue::encode(jsUndefined());
>+            }
>+
>+            if (symbol->privateName() == moduleLoaderFetchingIsCanceledSymbol) {
>+                moduleScript->notifyLoadWasCanceled();
>+                return JSValue::encode(jsUndefined());
>+            }
>+        }
>+
>+        VM& vm = exec->vm();
>+        auto scope = DECLARE_CATCH_SCOPE(vm);
>+        moduleScript->notifyLoadFailed(LoadableScript::Error {
>+            LoadableScript::ErrorType::CachedScript,
>+            LoadableScript::ConsoleMessage {
>+                MessageSource::JS,
>+                MessageLevel::Error,
>+                retrieveErrorMessage(*exec, vm, error, scope),
>+            }
>+        });
>+        return JSValue::encode(jsUndefined());
>+    });
>+
>+    promise.then(&state, &fulfillHandler, &rejectHandler);
>+}
>+
> TextPosition ScriptController::eventHandlerPosition() const
> {
>     // FIXME: If we are not currently parsing, we should use our current location
>@@ -520,7 +676,9 @@ JSValue ScriptController::executeScript(const ScriptSourceCode& sourceCode, Exce
>     if (!canExecuteScripts(AboutToExecuteScript) || isPaused())
>         return { }; // FIXME: Would jsNull be better?
> 
>-    Ref<Frame> protect(m_frame); // Script execution can destroy the frame, and thus the ScriptController.
>+    // FIXME: Preventing Frame from being destroyed is essentially unnecessary.
>+    // https://bugs.webkit.org/show_bug.cgi?id=164763
>+    Ref<Frame> protector(m_frame); // Script execution can destroy the frame, and thus the ScriptController.
> 
>     return evaluate(sourceCode, exceptionDetails);
> }
>diff --git a/Source/WebCore/bindings/js/ScriptController.h b/Source/WebCore/bindings/js/ScriptController.h
>index 44ff37e8478775fdaff9d855f8031900d17ef898..6bb2742a77902fef6ebe70cc49d6ab269ee6f083 100644
>--- a/Source/WebCore/bindings/js/ScriptController.h
>+++ b/Source/WebCore/bindings/js/ScriptController.h
>@@ -42,8 +42,10 @@ class ScriptValue;
> }
> 
> namespace JSC {
>-class JSGlobalObject;
> class ExecState;
>+class JSGlobalObject;
>+class JSInternalPromise;
>+class JSModuleRecord;
> 
> namespace Bindings {
> class Instance;
>@@ -53,11 +55,12 @@ class RootObject;
> 
> namespace WebCore {
> 
>+class CachedModuleScript;
> class Frame;
> class HTMLDocument;
> class HTMLPlugInElement;
>-class ScriptSourceCode;
> class SecurityOrigin;
>+class ScriptSourceCode;
> class Widget;
> 
> typedef HashMap<void*, RefPtr<JSC::Bindings::RootObject>> RootObjectMap;
>@@ -114,6 +117,17 @@ class ScriptController {
>     JSC::JSValue evaluate(const ScriptSourceCode&, ExceptionDetails* = nullptr);
>     JSC::JSValue evaluateInWorld(const ScriptSourceCode&, DOMWrapperWorld&, ExceptionDetails* = nullptr);
> 
>+    void loadModuleScriptInWorld(CachedModuleScript&, const String& moduleName, DOMWrapperWorld&, Element&);
>+    void loadModuleScript(CachedModuleScript&, const String& moduleName, Element&);
>+    void loadModuleScriptInWorld(CachedModuleScript&, const ScriptSourceCode&, DOMWrapperWorld&, Element&);
>+    void loadModuleScript(CachedModuleScript&, const ScriptSourceCode&, Element&);
>+
>+    JSC::JSValue linkAndEvaluateModuleScriptInWorld(CachedModuleScript& , DOMWrapperWorld&, Element&);
>+    JSC::JSValue linkAndEvaluateModuleScript(CachedModuleScript&, Element&);
>+
>+    JSC::JSValue evaluateModule(const URL&, JSC::JSModuleRecord&, DOMWrapperWorld&);
>+    JSC::JSValue evaluateModule(const URL&, JSC::JSModuleRecord&);
>+
>     WTF::TextPosition eventHandlerPosition() const;
> 
>     void enableEval();
>@@ -134,6 +148,9 @@ class ScriptController {
> 
>     const String* sourceURL() const { return m_sourceURL; } // 0 if we are not evaluating any script
> 
>+    const JSC::PrivateName& moduleLoaderAlreadyReportedErrorSymbol() const { return m_moduleLoaderAlreadyReportedErrorSymbol; }
>+    const JSC::PrivateName& moduleLoaderFetchingIsCanceledSymbol() const { return m_moduleLoaderFetchingIsCanceledSymbol; }
>+
>     void clearWindowShell(DOMWindow* newDOMWindow, bool goingIntoPageCache);
>     void updateDocument();
> 
>@@ -166,6 +183,7 @@ class ScriptController {
> 
> private:
>     WEBCORE_EXPORT JSDOMWindowShell* initScript(DOMWrapperWorld&);
>+    void setupModuleScriptHandlers(CachedModuleScript&, JSC::JSInternalPromise&, DOMWrapperWorld&);
> 
>     void disconnectPlatformScriptObjects();
> 
>@@ -174,6 +192,8 @@ class ScriptController {
>     const String* m_sourceURL;
> 
>     bool m_paused;
>+    JSC::PrivateName m_moduleLoaderAlreadyReportedErrorSymbol;
>+    JSC::PrivateName m_moduleLoaderFetchingIsCanceledSymbol;
> 
>     // The root object used for objects bound outside the context of a plugin, such
>     // as NPAPI plugins. The plugins using these objects prevent a page from being cached so they
>diff --git a/Source/WebCore/bindings/js/ScriptModuleLoader.cpp b/Source/WebCore/bindings/js/ScriptModuleLoader.cpp
>index 8e024c632346604badfdf9ce255f93c400591d40..c0247cfdf173f4d48e26ab95dcd3042d15882b0e 100644
>--- a/Source/WebCore/bindings/js/ScriptModuleLoader.cpp
>+++ b/Source/WebCore/bindings/js/ScriptModuleLoader.cpp
>@@ -26,9 +26,18 @@
> #include "config.h"
> #include "ScriptModuleLoader.h"
> 
>+#include "CachedModuleScriptLoader.h"
>+#include "CachedScript.h"
> #include "Document.h"
> #include "Frame.h"
> #include "JSDOMBinding.h"
>+#include "JSElement.h"
>+#include "LoadableModuleScript.h"
>+#include "MIMETypeRegistry.h"
>+#include "ScriptController.h"
>+#include "ScriptElement.h"
>+#include "ScriptSourceCode.h"
>+#include <runtime/JSInternalPromise.h>
> #include <runtime/JSInternalPromiseDeferred.h>
> #include <runtime/JSModuleRecord.h>
> #include <runtime/JSString.h>
>@@ -41,63 +50,124 @@ ScriptModuleLoader::ScriptModuleLoader(Document& document)
> {
> }
> 
>-JSC::JSInternalPromise* ScriptModuleLoader::resolve(JSC::JSGlobalObject* globalObject, JSC::ExecState* exec, JSC::JSModuleLoader*, JSC::JSValue moduleNameValue, JSC::JSValue importerModuleKey, JSC::JSValue)
>+ScriptModuleLoader::~ScriptModuleLoader()
> {
>-    JSC::JSInternalPromiseDeferred* deferred = JSC::JSInternalPromiseDeferred::create(exec, globalObject);
>+    for (auto& loader : m_loaders)
>+        const_cast<CachedModuleScriptLoader&>(loader.get()).clearClient();
>+}
>+
>+JSC::JSInternalPromise* ScriptModuleLoader::resolve(JSC::JSGlobalObject* jsGlobalObject, JSC::ExecState* exec, JSC::JSModuleLoader*, JSC::JSValue moduleNameValue, JSC::JSValue importerModuleKey, JSC::JSValue)
>+{
>+    auto& globalObject = *JSC::jsCast<JSDOMGlobalObject*>(jsGlobalObject);
>+    auto& jsPromise = *JSC::JSInternalPromiseDeferred::create(exec, &globalObject);
>+    auto promise = DeferredPromise::create(globalObject, jsPromise);
> 
>     // We use a Symbol as a special purpose; It means this module is an inline module.
>     // So there is no correct URL to retrieve the module source code. If the module name
>     // value is a Symbol, it is used directly as a module key.
>-    //
>-    // FIXME: Using symbols for an inline module is a current implementation details of WebKit.
>-    // Once the spec of this part is specified, we will recast these part.
>-    if (moduleNameValue.isSymbol())
>-        return deferred->resolve(exec, moduleNameValue);
>+    if (moduleNameValue.isSymbol()) {
>+        promise->resolve(asSymbol(moduleNameValue)->privateName());
>+        return jsPromise.promise();
>+    }
> 
>-    if (!moduleNameValue.isString())
>-        return deferred->reject(exec, JSC::createTypeError(exec, "Module name is not Symbol or String."));
>+    // https://html.spec.whatwg.org/multipage/webappapis.html#resolve-a-module-specifier
> 
>-    String moduleName = asString(moduleNameValue)->value(exec);
>+    if (!moduleNameValue.isString()) {
>+        promise->reject(TypeError, ASCIILiteral("Module specifier is not Symbol or String."));
>+        return jsPromise.promise();
>+    }
> 
>-    // Now, we consider the given moduleName as the same to the `import "..."` in the module code.
>-    // We use the completed URL as the unique module key.
>-    URL completedUrl;
>+    String specifier = asString(moduleNameValue)->value(exec);
> 
>-    if (importerModuleKey.isSymbol())
>-        completedUrl = m_document.completeURL(moduleName);
>-    else if (importerModuleKey.isUndefined())
>-        completedUrl = m_document.completeURL(moduleName);
>-    else if (importerModuleKey.isString()) {
>-        URL importerModuleUrl(URL(), asString(importerModuleKey)->value(exec));
>-        if (!importerModuleUrl.isValid())
>-            return deferred->reject(exec, JSC::createTypeError(exec, "Importer module key is an invalid URL."));
>-        completedUrl = m_document.completeURL(moduleName, importerModuleUrl);
>-    } else
>-        return deferred->reject(exec, JSC::createTypeError(exec, "Importer module key is not Symbol or String."));
>+    // 1. Apply the URL parser to specifier. If the result is not failure, return the result.
>+    URL absoluteURL(URL(), specifier);
>+    if (absoluteURL.isValid()) {
>+        promise->resolve(absoluteURL.string());
>+        return jsPromise.promise();
>+    }
> 
>-    if (!completedUrl.isValid())
>-        return deferred->reject(exec, JSC::createTypeError(exec, "Module name constructs an invalid URL."));
>+    // 2. If specifier does not start with the character U+002F SOLIDUS (/), the two-character sequence U+002E FULL STOP, U+002F SOLIDUS (./),
>+    //    or the three-character sequence U+002E FULL STOP, U+002E FULL STOP, U+002F SOLIDUS (../), return failure and abort these steps.
>+    if (!specifier.startsWith('/') && !specifier.startsWith("./") && !specifier.startsWith("../")) {
>+        promise->reject(TypeError, ASCIILiteral("Module specifier does not start with \"/\", \"./\", or \"../\"."));
>+        return jsPromise.promise();
>+    }
> 
>-    return deferred->resolve(exec, jsString(exec, completedUrl.string()));
>-}
>-
>-JSC::JSInternalPromise* ScriptModuleLoader::fetch(JSC::JSGlobalObject* globalObject, JSC::ExecState* exec, JSC::JSModuleLoader*, JSC::JSValue moduleKeyValue, JSC::JSValue)
>-{
>-    JSC::JSInternalPromiseDeferred* deferred = JSC::JSInternalPromiseDeferred::create(exec, globalObject);
>-
>-    if (moduleKeyValue.isSymbol())
>-        return deferred->reject(exec, JSC::createTypeError(exec, "Symbol module key should be already fulfilled with the inlined resource."));
>+    // 3. Return the result of applying the URL parser to specifier with script's base URL as the base URL.
> 
>-    if (!moduleKeyValue.isString())
>-        return deferred->reject(exec, JSC::createTypeError(exec, "Module key is not Symbol or String."));
>+    URL completedURL;
> 
>-    URL completedUrl(URL(), asString(moduleKeyValue)->value(exec));
>-    if (!completedUrl.isValid())
>-        return deferred->reject(exec, JSC::createTypeError(exec, "Module key is an invalid URL."));
>-
>-    // FIXME: Implement the module fetcher.
>+    bool isRootModule = importerModuleKey.isSymbol() || importerModuleKey.isUndefined();
>+    if (isRootModule)
>+        completedURL = m_document.completeURL(specifier);
>+    else if (importerModuleKey.isString()) {
>+        URL importerModuleRequestURL(URL(), asString(importerModuleKey)->value(exec));
>+        if (!importerModuleRequestURL.isValid()) {
>+            promise->reject(TypeError, ASCIILiteral("Importer module key is an invalid URL."));
>+            return jsPromise.promise();
>+        }
>+
>+        URL importerModuleResponseURL = m_requestURLToResponseURLMap.get(importerModuleRequestURL);
>+        if (!importerModuleResponseURL.isValid()) {
>+            promise->reject(TypeError, ASCIILiteral("Importer module has an invalid response URL."));
>+            return jsPromise.promise();
>+        }
>+
>+        completedURL = m_document.completeURL(specifier, importerModuleResponseURL);
>+    } else {
>+        promise->reject(TypeError, ASCIILiteral("Importer module key is not Symbol or String."));
>+        return jsPromise.promise();
>+    }
>+
>+    if (!completedURL.isValid()) {
>+        promise->reject(TypeError, ASCIILiteral("Module name constructs an invalid URL."));
>+        return jsPromise.promise();
>+    }
>+
>+    promise->resolve(completedURL.string());
>+    return jsPromise.promise();
>+}
> 
>-    return deferred->promise();
>+JSC::JSInternalPromise* ScriptModuleLoader::fetch(JSC::JSGlobalObject* jsGlobalObject, JSC::ExecState* exec, JSC::JSModuleLoader*, JSC::JSValue moduleKeyValue, JSC::JSValue initiator)
>+{
>+    auto& globalObject = *JSC::jsCast<JSDOMGlobalObject*>(jsGlobalObject);
>+    auto& jsPromise = *JSC::JSInternalPromiseDeferred::create(exec, &globalObject);
>+    auto deferred = DeferredPromise::create(globalObject, jsPromise);
>+    if (moduleKeyValue.isSymbol()) {
>+        deferred->reject(TypeError, ASCIILiteral("Symbol module key should be already fulfilled with the inlined resource."));
>+        return jsPromise.promise();
>+    }
>+
>+    if (!moduleKeyValue.isString()) {
>+        deferred->reject(TypeError, ASCIILiteral("Module key is not Symbol or String."));
>+        return jsPromise.promise();
>+    }
>+
>+    // https://html.spec.whatwg.org/multipage/webappapis.html#fetch-a-single-module-script
>+
>+    URL completedURL(URL(), asString(moduleKeyValue)->value(exec));
>+    if (!completedURL.isValid()) {
>+        deferred->reject(TypeError, ASCIILiteral("Module key is an invalid URL."));
>+        return jsPromise.promise();
>+    }
>+
>+    ASSERT_WITH_MESSAGE(JSC::jsDynamicCast<JSElement*>(initiator), "Initiator should be an JSElement");
>+    auto* scriptElement = toScriptElementIfPossible(&JSC::jsCast<JSElement*>(initiator)->wrapped());
>+    ASSERT_WITH_MESSAGE(scriptElement, "Initiator should be ScriptElement.");
>+
>+    if (auto* frame = m_document.frame()) {
>+        auto loader = CachedModuleScriptLoader::create(*this, deferred.get());
>+        m_loaders.add(loader.copyRef());
>+        if (!loader->load(*scriptElement, completedURL)) {
>+            loader->clearClient();
>+            m_loaders.remove(WTFMove(loader));
>+
>+            deferred->reject(frame->script().moduleLoaderAlreadyReportedErrorSymbol());
>+            return jsPromise.promise();
>+        }
>+    }
>+
>+    return jsPromise.promise();
> }
> 
> JSC::JSValue ScriptModuleLoader::evaluate(JSC::JSGlobalObject*, JSC::ExecState* exec, JSC::JSModuleLoader*, JSC::JSValue moduleKeyValue, JSC::JSValue moduleRecordValue, JSC::JSValue)
>@@ -108,24 +178,67 @@ JSC::JSValue ScriptModuleLoader::evaluate(JSC::JSGlobalObject*, JSC::ExecState*
>     // FIXME: Currently, we only support JSModuleRecord.
>     // Once the reflective part of the module loader is supported, we will handle arbitrary values.
>     // https://whatwg.github.io/loader/#registry-prototype-provide
>-    JSC::JSModuleRecord* moduleRecord = jsDynamicDowncast<JSC::JSModuleRecord*>(moduleRecordValue);
>+    auto* moduleRecord = jsDynamicDowncast<JSC::JSModuleRecord*>(moduleRecordValue);
>     if (!moduleRecord)
>         return JSC::jsUndefined();
> 
>-    URL sourceUrl;
>+    URL sourceURL;
>     if (moduleKeyValue.isSymbol())
>-        sourceUrl = m_document.url();
>+        sourceURL = m_document.url();
>     else if (moduleKeyValue.isString())
>-        sourceUrl = URL(URL(), asString(moduleKeyValue)->value(exec));
>+        sourceURL = URL(URL(), asString(moduleKeyValue)->value(exec));
>     else
>         return JSC::throwTypeError(exec, scope, ASCIILiteral("Module key is not Symbol or String."));
> 
>-    if (!sourceUrl.isValid())
>+    if (!sourceURL.isValid())
>         return JSC::throwTypeError(exec, scope, ASCIILiteral("Module key is an invalid URL."));
> 
>-    // FIXME: Implement evaluating module code.
>-
>+    if (auto* frame = m_document.frame())
>+        return frame->script().evaluateModule(sourceURL, *moduleRecord);
>     return JSC::jsUndefined();
> }
> 
>+void ScriptModuleLoader::notifyFinished(CachedModuleScriptLoader& loader, RefPtr<DeferredPromise> promise)
>+{
>+    // https://html.spec.whatwg.org/multipage/webappapis.html#fetch-a-single-module-script
>+
>+    if (!m_loaders.remove(&loader))
>+        return;
>+    loader.clearClient();
>+
>+    auto* cachedScript = loader.cachedScript();
>+
>+    bool failed = false;
>+
>+    if (cachedScript->resourceError().isAccessControl()) {
>+        promise->reject(TypeError, ASCIILiteral("Cross-origin script load denied by Cross-Origin Resource Sharing policy."));
>+        return;
>+    }
>+
>+    if (cachedScript->errorOccurred())
>+        failed = true;
>+    else if (!MIMETypeRegistry::isSupportedJavaScriptMIMEType(cachedScript->response().mimeType())) {
>+        // https://html.spec.whatwg.org/multipage/webappapis.html#fetch-a-single-module-script
>+        // The result of extracting a MIME type from response's header list (ignoring parameters) is not a JavaScript MIME type.
>+        // NOTE: For historical reasons, fetching a classic script does not include MIME type checking. In contrast, module scripts will fail to load if they are not of a correct MIME type.
>+        promise->reject(TypeError, makeString(
>+            "Refused to execute module script from '", cachedScript->url().stringCenterEllipsizedToLength(),
>+            "' because its MIME type ('", cachedScript->response().mimeType(), "') is not executable."));
>+        return;
>+    }
>+
>+    if (auto* frame = m_document.frame()) {
>+        if (failed) {
>+            // Reject a promise to propagate the error back all the way through module promise chains to the script element.
>+            promise->reject(frame->script().moduleLoaderAlreadyReportedErrorSymbol());
>+        } else if (cachedScript->wasCanceled())
>+            promise->reject(frame->script().moduleLoaderFetchingIsCanceledSymbol());
>+        else {
>+            m_requestURLToResponseURLMap.add(cachedScript->url(), cachedScript->response().url());
>+            // FIXME: Let's wrap around ScriptSourceCode to propagate it directly through the module pipeline.
>+            promise->resolve(ScriptSourceCode(cachedScript, JSC::SourceProviderSourceType::Module).source().toString());
>+        }
>+    }
>+}
>+
> }
>diff --git a/Source/WebCore/bindings/js/ScriptModuleLoader.h b/Source/WebCore/bindings/js/ScriptModuleLoader.h
>index a5dc8a655c5eefe4c5c94b496b8eb558d17edc1f..f78545e56e9c914964e8daa8912a1962ca787172 100644
>--- a/Source/WebCore/bindings/js/ScriptModuleLoader.h
>+++ b/Source/WebCore/bindings/js/ScriptModuleLoader.h
>@@ -25,6 +25,10 @@
> 
> #pragma once
> 
>+#include "CachedModuleScriptLoader.h"
>+#include "CachedModuleScriptLoaderClient.h"
>+#include "URL.h"
>+#include "URLHash.h"
> #include <runtime/JSCJSValue.h>
> #include <wtf/Noncopyable.h>
> 
>@@ -40,11 +44,13 @@ class JSModuleLoader;
> namespace WebCore {
> 
> class Document;
>+class JSDOMGlobalObject;
> 
>-class ScriptModuleLoader {
>-    WTF_MAKE_NONCOPYABLE(ScriptModuleLoader); WTF_MAKE_FAST_ALLOCATED;
>+class ScriptModuleLoader final : private CachedModuleScriptLoaderClient {
>+WTF_MAKE_NONCOPYABLE(ScriptModuleLoader); WTF_MAKE_FAST_ALLOCATED;
> public:
>     explicit ScriptModuleLoader(Document&);
>+    ~ScriptModuleLoader();
> 
>     Document& document() { return m_document; }
> 
>@@ -53,7 +59,11 @@ class ScriptModuleLoader {
>     JSC::JSValue evaluate(JSC::JSGlobalObject*, JSC::ExecState*, JSC::JSModuleLoader*, JSC::JSValue moduleKey, JSC::JSValue moduleRecord, JSC::JSValue initiator);
> 
> private:
>+    void notifyFinished(CachedModuleScriptLoader&, RefPtr<DeferredPromise>) final;
>+
>     Document& m_document;
>+    HashMap<URL, URL> m_requestURLToResponseURLMap;
>+    HashSet<Ref<CachedModuleScriptLoader>> m_loaders;
> };
> 
> } // namespace WebCore
>diff --git a/Source/WebCore/bindings/js/ScriptSourceCode.h b/Source/WebCore/bindings/js/ScriptSourceCode.h
>index 81446acc33d610fd564f12a252753f9dd45ed6f6..10711de223c12f297312c45b34e745fa0ca42ee6 100644
>--- a/Source/WebCore/bindings/js/ScriptSourceCode.h
>+++ b/Source/WebCore/bindings/js/ScriptSourceCode.h
>@@ -42,15 +42,15 @@ namespace WebCore {
> 
> class ScriptSourceCode {
> public:
>-    ScriptSourceCode(const String& source, const URL& url = URL(), const TextPosition& startPosition = TextPosition::minimumPosition())
>-        : m_provider(JSC::StringSourceProvider::create(source, url.isNull() ? String() : url.string(), startPosition))
>+    ScriptSourceCode(const String& source, const URL& url = URL(), const TextPosition& startPosition = TextPosition::minimumPosition(), JSC::SourceProviderSourceType sourceType = JSC::SourceProviderSourceType::Program)
>+        : m_provider(JSC::StringSourceProvider::create(source, url.isNull() ? String() : url.string(), startPosition, sourceType))
>         , m_code(m_provider, startPosition.m_line.oneBasedInt(), startPosition.m_column.oneBasedInt())
>         , m_url(url)
>     {
>     }
> 
>-    explicit ScriptSourceCode(CachedScript* cachedScript)
>-        : m_provider(CachedScriptSourceProvider::create(cachedScript))
>+    explicit ScriptSourceCode(CachedScript* cachedScript, JSC::SourceProviderSourceType sourceType)
>+        : m_provider(CachedScriptSourceProvider::create(cachedScript, sourceType))
>         , m_code(m_provider)
>         , m_cachedScript(cachedScript)
>     {
>diff --git a/Source/WebCore/dom/CurrentScriptIncrementer.h b/Source/WebCore/dom/CurrentScriptIncrementer.h
>index 151ed6509a92ebf50085c0db72a3e3e686855ed9..d08902334ed818d5f09bfa89b4e73f90ea84a741 100644
>--- a/Source/WebCore/dom/CurrentScriptIncrementer.h
>+++ b/Source/WebCore/dom/CurrentScriptIncrementer.h
>@@ -43,7 +43,8 @@ class CurrentScriptIncrementer {
>         if (!m_isHTMLScriptElement)
>             return;
>         auto& scriptElement = downcast<HTMLScriptElement>(element);
>-        m_document.pushCurrentScript(scriptElement.isInShadowTree() ? nullptr : &scriptElement);
>+        bool shouldPushNullForCurrentScript = scriptElement.isInShadowTree() || scriptElement.scriptType() == ScriptElement::ScriptType::Module;
>+        m_document.pushCurrentScript(shouldPushNullForCurrentScript ? nullptr : &scriptElement);
>     }
> 
>     ~CurrentScriptIncrementer()
>diff --git a/Source/WebCore/dom/LoadableClassicScript.cpp b/Source/WebCore/dom/LoadableClassicScript.cpp
>index 4f5ca953a04837effc114ac34e337937939b6109..94c1660e8db0bd78c2a26f09e9dc34ad5731fb92 100644
>--- a/Source/WebCore/dom/LoadableClassicScript.cpp
>+++ b/Source/WebCore/dom/LoadableClassicScript.cpp
>@@ -51,7 +51,7 @@ bool LoadableClassicScript::isLoaded() const
>     return m_cachedScript->isLoaded();
> }
> 
>-Optional<LoadableScript::Error> LoadableClassicScript::wasErrored() const
>+Optional<LoadableScript::Error> LoadableClassicScript::error() const
> {
>     if (m_error)
>         return m_error;
>@@ -101,8 +101,8 @@ void LoadableClassicScript::notifyFinished(CachedResource& resource)
> 
> void LoadableClassicScript::execute(ScriptElement& scriptElement)
> {
>-    ASSERT(!wasErrored());
>-    scriptElement.executeScript(ScriptSourceCode(m_cachedScript.get()));
>+    ASSERT(!error());
>+    scriptElement.executeScript(ScriptSourceCode(m_cachedScript.get(), JSC::SourceProviderSourceType::Program));
> }
> 
> }
>diff --git a/Source/WebCore/dom/LoadableClassicScript.h b/Source/WebCore/dom/LoadableClassicScript.h
>index fd38f77af7d344b8932912da29915a72ad9bd5c2..fe259502343d2e3f97fc14daffbfed9a8fed1d38 100644
>--- a/Source/WebCore/dom/LoadableClassicScript.h
>+++ b/Source/WebCore/dom/LoadableClassicScript.h
>@@ -40,17 +40,17 @@ namespace WebCore {
> // destroyed in order to guarantee that the data buffer will not be purged.
> class LoadableClassicScript final : public LoadableScript, private CachedResourceClient {
> public:
>-    ~LoadableClassicScript();
>+    virtual ~LoadableClassicScript();
> 
>     static Ref<LoadableClassicScript> create(CachedResourceHandle<CachedScript>&&);
>-    bool isLoaded() const override;
>-    Optional<Error> wasErrored() const override;
>-    bool wasCanceled() const override;
>+    bool isLoaded() const final;
>+    Optional<Error> error() const final;
>+    bool wasCanceled() const final;
> 
>     CachedScript& cachedScript() { return *m_cachedScript; }
>     bool isClassicScript() const final { return true; }
> 
>-    void execute(ScriptElement&) override;
>+    void execute(ScriptElement&) final;
> 
> private:
>     LoadableClassicScript(CachedResourceHandle<CachedScript>&& cachedScript) : m_cachedScript(WTFMove(cachedScript)) { }
>diff --git a/Source/WebCore/dom/LoadableModuleScript.cpp b/Source/WebCore/dom/LoadableModuleScript.cpp
>new file mode 100644
>index 0000000000000000000000000000000000000000..ca18e68db4304e0f64ab87e8157663110571a482
>--- /dev/null
>+++ b/Source/WebCore/dom/LoadableModuleScript.cpp
>@@ -0,0 +1,75 @@
>+/*
>+ * Copyright (C) 2016 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
>+ *    documentation and/or other materials provided with the distribution.
>+ *
>+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
>+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
>+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
>+ * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE INC. OR
>+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
>+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
>+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
>+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
>+ * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
>+ * (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 "config.h"
>+#include "LoadableModuleScript.h"
>+
>+#include "ScriptElement.h"
>+
>+namespace WebCore {
>+
>+Ref<LoadableModuleScript> LoadableModuleScript::create(CachedModuleScript& moduleScript)
>+{
>+    auto script = adoptRef(*new LoadableModuleScript(moduleScript));
>+    moduleScript.addClient(script.get());
>+    return script;
>+}
>+
>+LoadableModuleScript::LoadableModuleScript(CachedModuleScript& moduleScript)
>+    : m_moduleScript(moduleScript)
>+{
>+}
>+
>+LoadableModuleScript::~LoadableModuleScript()
>+{
>+    m_moduleScript->removeClient(*this);
>+}
>+
>+bool LoadableModuleScript::isLoaded() const
>+{
>+    return m_moduleScript->isLoaded();
>+}
>+
>+Optional<LoadableScript::Error> LoadableModuleScript::error() const
>+{
>+    return m_moduleScript->error();
>+}
>+
>+bool LoadableModuleScript::wasCanceled() const
>+{
>+    return m_moduleScript->wasCanceled();
>+}
>+
>+void LoadableModuleScript::notifyFinished(CachedModuleScript&)
>+{
>+    notifyClientFinished();
>+}
>+
>+void LoadableModuleScript::execute(ScriptElement& scriptElement)
>+{
>+    scriptElement.executeModuleScript(m_moduleScript.get());
>+}
>+
>+}
>diff --git a/Source/WebCore/dom/LoadableModuleScript.h b/Source/WebCore/dom/LoadableModuleScript.h
>new file mode 100644
>index 0000000000000000000000000000000000000000..0cfd0d67acb79e074a35d14136e25f2b95f6c1fb
>--- /dev/null
>+++ b/Source/WebCore/dom/LoadableModuleScript.h
>@@ -0,0 +1,64 @@
>+/*
>+ * Copyright (C) 2016 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
>+ *    documentation and/or other materials provided with the distribution.
>+ *
>+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
>+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
>+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
>+ * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE INC. OR
>+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
>+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
>+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
>+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
>+ * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
>+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
>+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
>+ */
>+
>+#pragma once
>+
>+#include "CachedModuleScript.h"
>+#include "CachedModuleScriptClient.h"
>+#include "LoadableScript.h"
>+#include <wtf/TypeCasts.h>
>+
>+namespace WebCore {
>+
>+class LoadableModuleScript final : public LoadableScript, private CachedModuleScriptClient {
>+public:
>+    virtual ~LoadableModuleScript();
>+
>+    static Ref<LoadableModuleScript> create(CachedModuleScript&);
>+
>+    bool isLoaded() const final;
>+    Optional<Error> error() const final;
>+    bool wasCanceled() const final;
>+
>+    CachedModuleScript& moduleScript() { return m_moduleScript.get(); }
>+    bool isModuleScript() const final { return true; }
>+
>+    void execute(ScriptElement&) final;
>+
>+    void setError(Error&&);
>+
>+private:
>+    LoadableModuleScript(CachedModuleScript&);
>+
>+    void notifyFinished(CachedModuleScript&) final;
>+
>+    Ref<CachedModuleScript> m_moduleScript;
>+};
>+
>+}
>+
>+SPECIALIZE_TYPE_TRAITS_BEGIN(WebCore::LoadableModuleScript)
>+    static bool isType(const WebCore::LoadableScript& script) { return script.isModuleScript(); }
>+SPECIALIZE_TYPE_TRAITS_END()
>diff --git a/Source/WebCore/dom/LoadableScript.h b/Source/WebCore/dom/LoadableScript.h
>index a8c50ed557b32e0bbe36a1d310021861ea6e8826..3ad17c559b473370bf76c4da7ed5480b1e47128d 100644
>--- a/Source/WebCore/dom/LoadableScript.h
>+++ b/Source/WebCore/dom/LoadableScript.h
>@@ -57,7 +57,7 @@ class LoadableScript : public RefCounted<LoadableScript> {
>     virtual ~LoadableScript() { }
> 
>     virtual bool isLoaded() const = 0;
>-    virtual Optional<Error> wasErrored() const = 0;
>+    virtual Optional<Error> error() const = 0;
>     virtual bool wasCanceled() const = 0;
> 
>     virtual void execute(ScriptElement&) = 0;
>@@ -66,7 +66,7 @@ class LoadableScript : public RefCounted<LoadableScript> {
>     void removeClient(LoadableScriptClient&);
> 
>     virtual bool isClassicScript() const { return false; }
>-    virtual bool isModuleGraph() const { return false; }
>+    virtual bool isModuleScript() const { return false; }
> 
> protected:
>     void notifyClientFinished();
>diff --git a/Source/WebCore/dom/PendingScript.cpp b/Source/WebCore/dom/PendingScript.cpp
>index 3ee4d28ef9941fba2a1a93e49f0654a7d3aab489..2be0e2eb9032dd389ab574d4808604f2e6bfb549 100644
>--- a/Source/WebCore/dom/PendingScript.cpp
>+++ b/Source/WebCore/dom/PendingScript.cpp
>@@ -83,9 +83,9 @@ bool PendingScript::isLoaded() const
>     return m_loadableScript && m_loadableScript->isLoaded();
> }
> 
>-bool PendingScript::wasErrored() const
>+bool PendingScript::error() const
> {
>-    return m_loadableScript && m_loadableScript->wasErrored();
>+    return m_loadableScript && m_loadableScript->error();
> }
> 
> void PendingScript::setClient(PendingScriptClient* client)
>diff --git a/Source/WebCore/dom/PendingScript.h b/Source/WebCore/dom/PendingScript.h
>index f15c9f75d706f31c2d3d199b86324582864ac94d..990f25083b01b027c4ac01417f8f4916a9e8e666 100644
>--- a/Source/WebCore/dom/PendingScript.h
>+++ b/Source/WebCore/dom/PendingScript.h
>@@ -58,7 +58,7 @@ class PendingScript final : public RefCounted<PendingScript>, public LoadableScr
>     bool needsLoading() const { return loadableScript(); }
> 
>     bool isLoaded() const;
>-    bool wasErrored() const;
>+    bool error() const;
> 
>     void notifyFinished(LoadableScript&) override;
> 
>diff --git a/Source/WebCore/dom/ScriptElement.cpp b/Source/WebCore/dom/ScriptElement.cpp
>index a68f41f5b13de6f2fda4c200378ad85d50014bd3..8150544b6bbd3b953e38f5aa007ff28fd50519ce 100644
>--- a/Source/WebCore/dom/ScriptElement.cpp
>+++ b/Source/WebCore/dom/ScriptElement.cpp
>@@ -24,6 +24,7 @@
> #include "config.h"
> #include "ScriptElement.h"
> 
>+#include "CachedModuleScript.h"
> #include "CachedResourceLoader.h"
> #include "CachedResourceRequest.h"
> #include "CachedScript.h"
>@@ -38,6 +39,7 @@
> #include "HTMLParserIdioms.h"
> #include "IgnoreDestructiveWriteCountIncrementer.h"
> #include "LoadableClassicScript.h"
>+#include "LoadableModuleScript.h"
> #include "MIMETypeRegistry.h"
> #include "Page.h"
> #include "PendingScript.h"
>@@ -68,6 +70,7 @@ ScriptElement::ScriptElement(Element& element, bool parserInserted, bool already
>     , m_willExecuteWhenDocumentFinishedParsing(false)
>     , m_forceAsync(!parserInserted)
>     , m_willExecuteInOrder(false)
>+    , m_isModuleScript(false)
> {
>     if (parserInserted && m_element.document().scriptableDocumentParser() && !m_element.document().isInDocumentWrite())
>         m_startLineNumber = m_element.document().scriptableDocumentParser()->textPosition().m_line;
>@@ -159,12 +162,13 @@ Optional<ScriptElement::ScriptType> ScriptElement::determineScriptType(LegacyTyp
>         return ScriptType::Classic;
>     if (supportLegacyTypes == AllowLegacyTypeInTypeAttribute && isLegacySupportedJavaScriptLanguage(type))
>         return ScriptType::Classic;
>-#if ENABLE(ES6_MODULES)
>+// Temporary commented out for EWS check. When landing, we will revert this comment out.
>+// #if ENABLE(ES6_MODULES)
>     // https://html.spec.whatwg.org/multipage/scripting.html#attr-script-type
>     // Setting the attribute to an ASCII case-insensitive match for the string "module" means that the script is a module script.
>     if (equalLettersIgnoringASCIICase(type, "module"))
>         return ScriptType::Module;
>-#endif
>+// #endif
>     return Nullopt;
> }
> 
>@@ -191,8 +195,12 @@ bool ScriptElement::prepareScript(const TextPosition& scriptStartPosition, Legac
>     if (!m_element.inDocument())
>         return false;
> 
>-    if (!determineScriptType(supportLegacyTypes))
>+    ScriptType scriptType = ScriptType::Classic;
>+    if (Optional<ScriptType> result = determineScriptType(supportLegacyTypes))
>+        scriptType = result.value();
>+    else
>         return false;
>+    m_isModuleScript = scriptType == ScriptType::Module;
> 
>     if (wasParserInserted) {
>         m_parserInserted = true;
>@@ -213,38 +221,50 @@ bool ScriptElement::prepareScript(const TextPosition& scriptStartPosition, Legac
>     if (!document.frame()->script().canExecuteScripts(AboutToExecuteScript))
>         return false;
> 
>-    if (!isScriptForEventSupported())
>+    if (scriptType == ScriptType::Classic && !isScriptForEventSupported())
>         return false;
> 
>+    // According to the spec, the module tag ignores the "charset" attribute as the same to the worker's
>+    // importScript. But WebKit supports the "charset" for importScript intentionally. So to be consistent,
>+    // even for the module tags, we handle the "charset" attribute.
>     if (!charsetAttributeValue().isEmpty())
>         m_characterEncoding = charsetAttributeValue();
>     else
>         m_characterEncoding = document.charset();
> 
>-    if (hasSourceAttribute()) {
>-        if (!requestClassicScript(sourceAttributeValue()))
>+    if (scriptType == ScriptType::Classic) {
>+        if (hasSourceAttribute()) {
>+            if (!requestClassicScript(sourceAttributeValue()))
>+                return false;
>+        }
>+    } else {
>+        ASSERT(scriptType == ScriptType::Module);
>+        if (!requestModuleScript(scriptStartPosition))
>             return false;
>     }
> 
>-    if (hasSourceAttribute() && deferAttributeValue() && m_parserInserted && !asyncAttributeValue()) {
>+    bool isParserInsertedDeferredScript = (scriptType == ScriptType::Classic && hasSourceAttribute() && deferAttributeValue() && m_parserInserted && !asyncAttributeValue()) || (scriptType == ScriptType::Module && m_parserInserted && !asyncAttributeValue());
>+    if (isParserInsertedDeferredScript) {
>         m_willExecuteWhenDocumentFinishedParsing = true;
>         m_willBeParserExecuted = true;
>-    } else if (hasSourceAttribute() && m_parserInserted && !asyncAttributeValue())
>-        m_willBeParserExecuted = true;
>-    else if (!hasSourceAttribute() && m_parserInserted && !document.haveStylesheetsLoaded()) {
>+    } else if (scriptType == ScriptType::Classic && hasSourceAttribute() && m_parserInserted && !asyncAttributeValue()) {
>+        ASSERT(scriptType == ScriptType::Classic);
>         m_willBeParserExecuted = true;
>-        m_readyToBeParserExecuted = true;
>-    } else if (hasSourceAttribute() && !asyncAttributeValue() && !m_forceAsync) {
>-        ASSERT(m_loadableScript);
>+    } else if ((scriptType == ScriptType::Classic && hasSourceAttribute() && !asyncAttributeValue() && !m_forceAsync) || (scriptType == ScriptType::Module && !asyncAttributeValue() && !m_forceAsync)) {
>         m_willExecuteInOrder = true;
>+        ASSERT(m_loadableScript);
>         document.scriptRunner()->queueScriptForExecution(this, *m_loadableScript, ScriptRunner::IN_ORDER_EXECUTION);
>-    } else if (hasSourceAttribute()) {
>+    } else if (hasSourceAttribute() || scriptType == ScriptType::Module) {
>         ASSERT(m_loadableScript);
>-        m_element.document().scriptRunner()->queueScriptForExecution(this, *m_loadableScript, ScriptRunner::ASYNC_EXECUTION);
>+        document.scriptRunner()->queueScriptForExecution(this, *m_loadableScript, ScriptRunner::ASYNC_EXECUTION);
>+    } else if (!hasSourceAttribute() && m_parserInserted && !document.haveStylesheetsLoaded()) {
>+        ASSERT(scriptType == ScriptType::Classic);
>+        m_willBeParserExecuted = true;
>+        m_readyToBeParserExecuted = true;
>     } else {
>-        // Reset line numbering for nested writes.
>+        ASSERT(scriptType == ScriptType::Classic);
>         TextPosition position = document.isInDocumentWrite() ? TextPosition() : scriptStartPosition;
>-        executeScript(ScriptSourceCode(scriptContent(), document.url(), position));
>+        executeScript(ScriptSourceCode(scriptContent(), document.url(), position, JSC::SourceProviderSourceType::Program));
>     }
> 
>     return true;
>@@ -261,7 +281,9 @@ bool ScriptElement::requestClassicScript(const String& sourceURL)
> 
>     ASSERT(!m_loadableScript);
>     if (!stripLeadingAndTrailingHTMLSpaces(sourceURL).isEmpty()) {
>-        auto request = requestScriptWithCache(m_element.document().completeURL(sourceURL), m_element.attributeWithoutSynchronization(HTMLNames::nonceAttr));
>+        String nonceAttribute = m_element.attributeWithoutSynchronization(HTMLNames::nonceAttr);
>+        String crossOriginMode = m_element.attributeWithoutSynchronization(HTMLNames::crossoriginAttr);
>+        auto request = requestScriptWithCache(m_element.document().completeURL(sourceURL), ScriptType::Classic, nonceAttribute, crossOriginMode);
>         if (request) {
>             m_loadableScript = LoadableClassicScript::create(WTFMove(request));
>             m_isExternalScript = true;
>@@ -277,7 +299,63 @@ bool ScriptElement::requestClassicScript(const String& sourceURL)
>     return false;
> }
> 
>-CachedResourceHandle<CachedScript> ScriptElement::requestScriptWithCache(const URL& sourceURL, const String& nonceAttribute)
>+bool ScriptElement::requestModuleScript(const TextPosition& scriptStartPosition)
>+{
>+    String nonce = m_element.attributeWithoutSynchronization(HTMLNames::nonceAttr);
>+    String crossOriginMode = m_element.attributeWithoutSynchronization(HTMLNames::crossoriginAttr);
>+
>+    if (hasSourceAttribute()) {
>+        String sourceURL = sourceAttributeValue();
>+        Ref<Document> originalDocument(m_element.document());
>+        if (!m_element.dispatchBeforeLoadEvent(sourceURL))
>+            return false;
>+
>+        bool didEventListenerDisconnectThisElement = !m_element.inDocument() || &m_element.document() != originalDocument.ptr();
>+        if (didEventListenerDisconnectThisElement)
>+            return false;
>+
>+        if (stripLeadingAndTrailingHTMLSpaces(sourceURL).isEmpty()) {
>+            dispatchErrorEvent();
>+            return false;
>+        }
>+
>+        auto moduleScriptRootURL = m_element.document().completeURL(sourceURL);
>+        if (!moduleScriptRootURL.isValid()) {
>+            dispatchErrorEvent();
>+            return false;
>+        }
>+
>+        m_isExternalScript = true;
>+        auto moduleScript = CachedModuleScript::create(nonce, crossOriginMode);
>+        m_loadableScript = LoadableModuleScript::create(moduleScript.get());
>+        moduleScript->load(m_element, moduleScriptRootURL);
>+        return true;
>+    }
>+
>+    TextPosition position = m_element.document().isInDocumentWrite() ? TextPosition() : scriptStartPosition;
>+    ScriptSourceCode sourceCode(scriptContent(), m_element.document().url(), position, JSC::SourceProviderSourceType::Module);
>+
>+    ASSERT(m_element.document().contentSecurityPolicy());
>+    const auto& contentSecurityPolicy = *m_element.document().contentSecurityPolicy();
>+    bool hasKnownNonce = contentSecurityPolicy.allowScriptWithNonce(nonce, m_element.isInUserAgentShadowTree());
>+    if (!contentSecurityPolicy.allowInlineScript(m_element.document().url(), m_startLineNumber, sourceCode.source().toStringWithoutCopying(), hasKnownNonce))
>+        return false;
>+
>+    auto moduleScript = CachedModuleScript::create(nonce, crossOriginMode);
>+    m_loadableScript = LoadableModuleScript::create(moduleScript.get());
>+    moduleScript->load(m_element, sourceCode);
>+    return true;
>+}
>+
>+CachedResourceHandle<CachedScript> ScriptElement::requestScriptWithCacheForModuleScript(const URL& sourceURL)
>+{
>+    ASSERT(m_loadableScript);
>+    ASSERT(is<LoadableModuleScript>(*m_loadableScript));
>+    auto& moduleScript = downcast<LoadableModuleScript>(*m_loadableScript);
>+    return requestScriptWithCache(sourceURL, ScriptType::Module, moduleScript.moduleScript().nonce(), moduleScript.moduleScript().crossOriginMode());
>+}
>+
>+CachedResourceHandle<CachedScript> ScriptElement::requestScriptWithCache(const URL& sourceURL, ScriptType scriptType, const String& nonceAttribute, const String& crossOriginMode)
> {
>     Document& document = m_element.document();
>     auto* settings = document.settings();
>@@ -290,7 +368,10 @@ CachedResourceHandle<CachedScript> ScriptElement::requestScriptWithCache(const U
>     options.contentSecurityPolicyImposition = hasKnownNonce ? ContentSecurityPolicyImposition::SkipPolicyCheck : ContentSecurityPolicyImposition::DoPolicyCheck;
> 
>     CachedResourceRequest request(ResourceRequest(sourceURL), options);
>-    request.setAsPotentiallyCrossOrigin(m_element.attributeWithoutSynchronization(HTMLNames::crossoriginAttr), document);
>+    if (scriptType == ScriptType::Classic)
>+        request.setAsPotentiallyCrossOrigin(crossOriginMode, document);
>+    else
>+        request.setAsPotentiallyCrossOriginForModuleScript(crossOriginMode, document);
>     request.upgradeInsecureRequestIfNeeded(document);
> 
>     request.setCharset(scriptCharset());
>@@ -314,26 +395,45 @@ void ScriptElement::executeScript(const ScriptSourceCode& sourceCode)
>             return;
>     }
> 
>-    Ref<Document> document(m_element.document());
>-    if (Frame* frame = document->frame()) {
>-        IgnoreDestructiveWriteCountIncrementer ignoreDesctructiveWriteCountIncrementer(m_isExternalScript ? document.ptr() : nullptr);
>-        CurrentScriptIncrementer currentScriptIncrementer(document, m_element);
>+    auto& document = m_element.document();
>+    auto* frame = document.frame();
>+    if (!frame)
>+        return;
> 
>-        // Create a script from the script element node, using the script
>-        // block's source and the script block's type.
>-        // Note: This is where the script is compiled and actually executed.
>-        frame->script().evaluate(sourceCode);
>-    }
>+    IgnoreDestructiveWriteCountIncrementer ignoreDesctructiveWriteCountIncrementer(m_isExternalScript ? &document : nullptr);
>+    CurrentScriptIncrementer currentScriptIncrementer(document, m_element);
>+
>+    // Create a script from the script element node, using the script
>+    // block's source and the script block's type.
>+    // Note: This is where the script is compiled and actually executed.
>+    frame->script().evaluate(sourceCode);
>+}
>+
>+void ScriptElement::executeModuleScript(CachedModuleScript& moduleScript)
>+{
>+    // https://html.spec.whatwg.org/multipage/scripting.html#execute-the-script-block
>+
>+    ASSERT(!moduleScript.error());
>+
>+    auto& document = m_element.document();
>+    auto* frame = document.frame();
>+    if (!frame)
>+        return;
>+
>+    IgnoreDestructiveWriteCountIncrementer ignoreDesctructiveWriteCountIncrementer(&document);
>+    CurrentScriptIncrementer currentScriptIncrementer(document, m_element);
>+
>+    frame->script().linkAndEvaluateModuleScript(moduleScript, element());
> }
> 
> void ScriptElement::executeScriptAndDispatchEvent(LoadableScript& loadableScript)
> {
>-    if (Optional<LoadableScript::Error> error = loadableScript.wasErrored()) {
>+    if (Optional<LoadableScript::Error> error = loadableScript.error()) {
>         if (Optional<LoadableScript::ConsoleMessage> message = error->consoleMessage)
>             m_element.document().addConsoleMessage(message->source, message->level, message->message);
>         dispatchErrorEvent();
>     } else if (!loadableScript.wasCanceled()) {
>-        ASSERT(!loadableScript.wasErrored());
>+        ASSERT(!loadableScript.error());
>         loadableScript.execute(*this);
>         dispatchLoadEvent();
>     }
>@@ -344,8 +444,9 @@ void ScriptElement::executeScriptForScriptRunner(PendingScript& pendingScript)
>     if (auto* loadableScript = pendingScript.loadableScript())
>         executeScriptAndDispatchEvent(*loadableScript);
>     else {
>-        ASSERT(!pendingScript.wasErrored());
>-        executeScript(ScriptSourceCode(scriptContent(), m_element.document().url(), pendingScript.startingPosition()));
>+        ASSERT(!pendingScript.error());
>+        JSC::SourceProviderSourceType sourceType = scriptType() == ScriptType::Module ? JSC::SourceProviderSourceType::Module : JSC::SourceProviderSourceType::Program;
>+        executeScript(ScriptSourceCode(scriptContent(), m_element.document().url(), pendingScript.startingPosition(), sourceType));
>         dispatchLoadEvent();
>     }
> }
>diff --git a/Source/WebCore/dom/ScriptElement.h b/Source/WebCore/dom/ScriptElement.h
>index 18e33b54ea750f059c1cd0ffeda2393aaaa28cac..48f6c44ee10eaf3768e6b4e6e476de10b5c9cf64 100644
>--- a/Source/WebCore/dom/ScriptElement.h
>+++ b/Source/WebCore/dom/ScriptElement.h
>@@ -37,6 +37,7 @@ class Element;
> class PendingScript;
> class ScriptElement;
> class ScriptSourceCode;
>+class CachedModuleScript;
> 
> class ScriptElement {
> public:
>@@ -51,6 +52,7 @@ class ScriptElement {
>     String scriptCharset() const { return m_characterEncoding; }
>     WEBCORE_EXPORT String scriptContent() const;
>     void executeScript(const ScriptSourceCode&);
>+    void executeModuleScript(CachedModuleScript&);
> 
>     void executeScriptForScriptRunner(PendingScript&);
> 
>@@ -65,6 +67,12 @@ class ScriptElement {
>     bool willExecuteInOrder() const { return m_willExecuteInOrder; }
>     LoadableScript* loadableScript() { return m_loadableScript.get(); }
> 
>+    CachedResourceHandle<CachedScript> requestScriptWithCacheForModuleScript(const URL&);
>+
>+    // https://html.spec.whatwg.org/multipage/scripting.html#concept-script-type
>+    enum class ScriptType { Classic, Module };
>+    ScriptType scriptType() const { return m_isModuleScript ? ScriptType::Module : ScriptType::Classic; }
>+
> protected:
>     ScriptElement(Element&, bool createdByParser, bool isEvaluated);
> 
>@@ -83,15 +91,14 @@ class ScriptElement {
> private:
>     void executeScriptAndDispatchEvent(LoadableScript&);
> 
>-    // https://html.spec.whatwg.org/multipage/scripting.html#concept-script-type
>-    enum class ScriptType { Classic, Module };
>     Optional<ScriptType> determineScriptType(LegacyTypeSupport) const;
>     bool ignoresLoadRequest() const;
>     bool isScriptForEventSupported() const;
> 
>-    CachedResourceHandle<CachedScript> requestScriptWithCache(const URL&, const String&);
>+    CachedResourceHandle<CachedScript> requestScriptWithCache(const URL&, ScriptType, const String& nonceAttribute, const String& crossoriginAttribute);
> 
>     bool requestClassicScript(const String& sourceURL);
>+    bool requestModuleScript(const TextPosition& scriptStartPosition);
> 
>     virtual String sourceAttributeValue() const = 0;
>     virtual String charsetAttributeValue() const = 0;
>@@ -114,6 +121,7 @@ class ScriptElement {
>     bool m_willExecuteWhenDocumentFinishedParsing : 1;
>     bool m_forceAsync : 1;
>     bool m_willExecuteInOrder : 1;
>+    bool m_isModuleScript : 1;
>     String m_characterEncoding;
>     String m_fallbackCharacterEncoding;
>     RefPtr<LoadableScript> m_loadableScript;
>diff --git a/Source/WebCore/html/parser/CSSPreloadScanner.cpp b/Source/WebCore/html/parser/CSSPreloadScanner.cpp
>index 9a64c51b6208e3604042f1dcab0f5bb78fec1765..81008a360b50d3dbe54fea2e355ca0c4967cd2fb 100644
>--- a/Source/WebCore/html/parser/CSSPreloadScanner.cpp
>+++ b/Source/WebCore/html/parser/CSSPreloadScanner.cpp
>@@ -203,7 +203,7 @@ void CSSPreloadScanner::emitRule()
>         if (!url.isEmpty()) {
>             URL baseElementURL; // FIXME: This should be passed in from the HTMLPreloadScanner via scan(): without it we will get relative URLs wrong.
>             // FIXME: Should this be including the charset in the preload request?
>-            m_requests->append(std::make_unique<PreloadRequest>("css", url, baseElementURL, CachedResource::CSSStyleSheet, String()));
>+            m_requests->append(std::make_unique<PreloadRequest>("css", url, baseElementURL, CachedResource::CSSStyleSheet, String(), PreloadRequest::ScriptType::Classic));
>         }
>         m_state = Initial;
>     } else if (equalLettersIgnoringASCIICase(rule, "charset"))
>diff --git a/Source/WebCore/html/parser/HTMLPreloadScanner.cpp b/Source/WebCore/html/parser/HTMLPreloadScanner.cpp
>index 1a1b405a02de87399b38dfba67469e0f3bec1e1b..13f9caa82fd6e1f794737718e82d5a559494f7f9 100644
>--- a/Source/WebCore/html/parser/HTMLPreloadScanner.cpp
>+++ b/Source/WebCore/html/parser/HTMLPreloadScanner.cpp
>@@ -144,8 +144,12 @@ class TokenPreloadScanner::StartTagScanner {
>         if (!shouldPreload())
>             return nullptr;
> 
>-        auto request = std::make_unique<PreloadRequest>(initiatorFor(m_tagId), m_urlToLoad, predictedBaseURL, resourceType(), m_mediaAttribute);
>+        auto request = std::make_unique<PreloadRequest>(initiatorFor(m_tagId), m_urlToLoad, predictedBaseURL, resourceType(), m_mediaAttribute, m_scriptType);
>         request->setCrossOriginMode(m_crossOriginMode);
>+
>+        // According to the spec, the module tag ignores the "charset" attribute as the same to the worker's
>+        // importScript. But WebKit supports the "charset" for importScript intentionally. So to be consistent,
>+        // even for the module tags, we handle the "charset" attribute.
>         request->setCharset(charset());
>         return request;
>     }
>@@ -205,6 +209,10 @@ class TokenPreloadScanner::StartTagScanner {
>             }
>             break;
>         case TagId::Script:
>+            if (match(attributeName, typeAttr)) {
>+                m_scriptType = equalLettersIgnoringASCIICase(attributeValue, "module") ? PreloadRequest::ScriptType::Module : PreloadRequest::ScriptType::Classic;
>+                break;
>+            }
>             processImageAndScriptAttribute(attributeName, attributeValue);
>             break;
>         case TagId::Link:
>@@ -318,6 +326,7 @@ class TokenPreloadScanner::StartTagScanner {
>     bool m_metaIsViewport;
>     bool m_inputIsImage;
>     float m_deviceScaleFactor;
>+    PreloadRequest::ScriptType m_scriptType { PreloadRequest::ScriptType::Classic };
> };
> 
> TokenPreloadScanner::TokenPreloadScanner(const URL& documentURL, float deviceScaleFactor)
>diff --git a/Source/WebCore/html/parser/HTMLResourcePreloader.cpp b/Source/WebCore/html/parser/HTMLResourcePreloader.cpp
>index f3632651b1a95ba1778a572b2bc9c594fbe14d69..4822cb80444765c682348a282a504c75af30182d 100644
>--- a/Source/WebCore/html/parser/HTMLResourcePreloader.cpp
>+++ b/Source/WebCore/html/parser/HTMLResourcePreloader.cpp
>@@ -45,7 +45,10 @@ CachedResourceRequest PreloadRequest::resourceRequest(Document& document)
>     ASSERT(isMainThread());
>     CachedResourceRequest request(completeURL(document), CachedResourceLoader::defaultCachedResourceOptions());
>     request.setInitiator(m_initiator);
>-    request.setAsPotentiallyCrossOrigin(m_crossOriginMode, document);
>+    if (m_scriptType == ScriptType::Module)
>+        request.setAsPotentiallyCrossOriginForModuleScript(m_crossOriginMode, document);
>+    else
>+        request.setAsPotentiallyCrossOrigin(m_crossOriginMode, document);
>     return request;
> }
> 
>diff --git a/Source/WebCore/html/parser/HTMLResourcePreloader.h b/Source/WebCore/html/parser/HTMLResourcePreloader.h
>index 29debc539ca6b9728039ee6c26721646ff65266f..2eeb65c3ef04095803e9bb17e2a66bddfeb3ae34 100644
>--- a/Source/WebCore/html/parser/HTMLResourcePreloader.h
>+++ b/Source/WebCore/html/parser/HTMLResourcePreloader.h
>@@ -33,12 +33,17 @@ namespace WebCore {
> class PreloadRequest {
>     WTF_MAKE_FAST_ALLOCATED;
> public:
>-    PreloadRequest(const String& initiator, const String& resourceURL, const URL& baseURL, CachedResource::Type resourceType, const String& mediaAttribute)
>+    enum class ScriptType {
>+        Classic,
>+        Module,
>+    };
>+    PreloadRequest(const String& initiator, const String& resourceURL, const URL& baseURL, CachedResource::Type resourceType, const String& mediaAttribute, ScriptType scriptType)
>         : m_initiator(initiator)
>         , m_resourceURL(resourceURL)
>         , m_baseURL(baseURL.isolatedCopy())
>         , m_resourceType(resourceType)
>         , m_mediaAttribute(mediaAttribute)
>+        , m_scriptType(scriptType)
>     {
>     }
> 
>@@ -60,6 +65,7 @@ class PreloadRequest {
>     CachedResource::Type m_resourceType;
>     String m_mediaAttribute;
>     String m_crossOriginMode;
>+    ScriptType m_scriptType;
> };
> 
> typedef Vector<std::unique_ptr<PreloadRequest>> PreloadRequestStream;
>diff --git a/Source/WebCore/html/parser/HTMLScriptRunner.h b/Source/WebCore/html/parser/HTMLScriptRunner.h
>index 95f72a5094a773cd210fba410d8f36ac1350c9ef..76800d713ce7d2e4635a66235b167c19f457c803 100644
>--- a/Source/WebCore/html/parser/HTMLScriptRunner.h
>+++ b/Source/WebCore/html/parser/HTMLScriptRunner.h
>@@ -72,7 +72,6 @@ class HTMLScriptRunner {
>     void watchForLoad(PendingScript&);
>     void stopWatchingForLoad(PendingScript&);
>     bool isPendingScriptReady(const PendingScript&);
>-    ScriptSourceCode sourceFromPendingScript(const PendingScript&, bool& errorOccurred) const;
> 
>     Document* m_document;
>     HTMLScriptRunnerHost& m_host;
>diff --git a/Source/WebCore/loader/cache/CachedResourceRequest.cpp b/Source/WebCore/loader/cache/CachedResourceRequest.cpp
>index 6ce8aab39d982ee95497ff2c65497dbefa44bda5..d61635f78e6ed270586f8f20e490734c14e25db3 100644
>--- a/Source/WebCore/loader/cache/CachedResourceRequest.cpp
>+++ b/Source/WebCore/loader/cache/CachedResourceRequest.cpp
>@@ -82,20 +82,38 @@ const AtomicString& CachedResourceRequest::initiatorName() const
>     return defaultName;
> }
> 
>-void CachedResourceRequest::setAsPotentiallyCrossOrigin(const String& mode, Document& document)
>+void CachedResourceRequest::setAsPotentiallyCrossOriginImpl(const String& mode, Document& document, CrossOriginSettingContext crossOriginSettingContext)
> {
>     ASSERT(m_options.mode == FetchOptions::Mode::NoCors);
>     ASSERT(document.securityOrigin());
> 
>     m_origin = document.securityOrigin();
> 
>-    if (mode.isNull())
>-        return;
>-    m_options.mode = FetchOptions::Mode::Cors;
>-    m_options.credentials = equalLettersIgnoringASCIICase(mode, "use-credentials") ? FetchOptions::Credentials::Include : FetchOptions::Credentials::SameOrigin;
>-    m_options.allowCredentials = equalLettersIgnoringASCIICase(mode, "use-credentials") ? AllowStoredCredentials : DoNotAllowStoredCredentials;
>+    if (mode.isNull()) {
>+        if (crossOriginSettingContext != CrossOriginSettingContext::ModuleScript)
>+            return;
>+        // https://html.spec.whatwg.org/multipage/webappapis.html#fetch-a-single-module-script
>+        m_options.mode = FetchOptions::Mode::Cors;
>+        m_options.credentials = FetchOptions::Credentials::Omit;
>+        m_options.allowCredentials = DoNotAllowStoredCredentials;
>+    } else {
>+        m_options.mode = FetchOptions::Mode::Cors;
>+        m_options.credentials = equalLettersIgnoringASCIICase(mode, "use-credentials") ? FetchOptions::Credentials::Include : FetchOptions::Credentials::SameOrigin;
>+        m_options.allowCredentials = equalLettersIgnoringASCIICase(mode, "use-credentials") ? AllowStoredCredentials : DoNotAllowStoredCredentials;
>+    }
> 
>     WebCore::updateRequestForAccessControl(m_resourceRequest, *document.securityOrigin(), m_options.allowCredentials);
>+
>+}
>+
>+void CachedResourceRequest::setAsPotentiallyCrossOrigin(const String& mode, Document& document)
>+{
>+    setAsPotentiallyCrossOriginImpl(mode, document, CrossOriginSettingContext::Normal);
>+}
>+
>+void CachedResourceRequest::setAsPotentiallyCrossOriginForModuleScript(const String& mode, Document& document)
>+{
>+    setAsPotentiallyCrossOriginImpl(mode, document, CrossOriginSettingContext::ModuleScript);
> }
> 
> void CachedResourceRequest::updateForAccessControl(Document& document)
>diff --git a/Source/WebCore/loader/cache/CachedResourceRequest.h b/Source/WebCore/loader/cache/CachedResourceRequest.h
>index ae4b9677041192668777f54d8a0b9e415e775144..f02a814d1363a57f5bcae84ad2d6ba0641acbf24 100644
>--- a/Source/WebCore/loader/cache/CachedResourceRequest.h
>+++ b/Source/WebCore/loader/cache/CachedResourceRequest.h
>@@ -65,6 +65,7 @@ class CachedResourceRequest {
>     void setCachingPolicy(CachingPolicy policy) { m_options.cachingPolicy = policy;  }
> 
>     void setAsPotentiallyCrossOrigin(const String&, Document&);
>+    void setAsPotentiallyCrossOriginForModuleScript(const String&, Document&);
>     void updateForAccessControl(Document&);
> 
>     void updateReferrerOriginAndUserAgentHeaders(FrameLoader&, ReferrerPolicy);
>@@ -89,6 +90,9 @@ class CachedResourceRequest {
>     static String splitFragmentIdentifierFromRequestURL(ResourceRequest&);
> 
> private:
>+    enum class CrossOriginSettingContext { Normal, ModuleScript };
>+    void setAsPotentiallyCrossOriginImpl(const String&, Document&, CrossOriginSettingContext);
>+
>     ResourceRequest m_resourceRequest;
>     String m_charset;
>     ResourceLoaderOptions m_options;
>diff --git a/Source/WebCore/xml/parser/XMLDocumentParser.cpp b/Source/WebCore/xml/parser/XMLDocumentParser.cpp
>index cf6f16df9d7a3312a3b5dd8b3f3b8ed203ee096d..f1ff7b9f48677bebfe5b527b57eda8b7629edbad 100644
>--- a/Source/WebCore/xml/parser/XMLDocumentParser.cpp
>+++ b/Source/WebCore/xml/parser/XMLDocumentParser.cpp
>@@ -232,7 +232,9 @@ void XMLDocumentParser::notifyFinished(CachedResource& unusedResource)
>     ASSERT_UNUSED(unusedResource, &unusedResource == m_pendingScript);
>     ASSERT(m_pendingScript->accessCount() > 0);
> 
>-    ScriptSourceCode sourceCode(m_pendingScript.get());
>+    // FIXME: Support ES6 modules in XML document.
>+    // https://bugs.webkit.org/show_bug.cgi?id=161651
>+    ScriptSourceCode sourceCode(m_pendingScript.get(), JSC::SourceProviderSourceType::Program);
>     bool errorOccurred = m_pendingScript->errorOccurred();
>     bool wasCanceled = m_pendingScript->wasCanceled();
> 
>diff --git a/LayoutTests/ChangeLog b/LayoutTests/ChangeLog
>index a991b9bda5b9db7b9da2469f1bd968421e38f06c..34f04688f139ed82ac268d3c3e17cb7c6c19e80f 100644
>--- a/LayoutTests/ChangeLog
>+++ b/LayoutTests/ChangeLog
>@@ -1,3 +1,123 @@
>+2016-11-14  Yusuke Suzuki  <utatane.tea@gmail.com>
>+
>+        [ES6] Integrate ES6 Modules into WebCore
>+        https://bugs.webkit.org/show_bug.cgi?id=148897
>+
>+        Reviewed by NOBODY (OOPS!).
>+
>+        * TestExpectations:
>+        * http/tests/misc/module-absolute-url-expected.txt: Added.
>+        * http/tests/misc/module-absolute-url.html: Added.
>+        * http/tests/misc/module-script-async-expected.txt: Added.
>+        * http/tests/misc/module-script-async.html: Added.
>+        * http/tests/misc/resources/module-absolute-url.js: Added.
>+        * http/tests/misc/resources/module-absolute-url2.js: Added.
>+        * http/tests/security/contentSecurityPolicy/1.1/module-scriptnonce-allowed-expected.txt: Added.
>+        * http/tests/security/contentSecurityPolicy/1.1/module-scriptnonce-allowed.html: Added.
>+        * http/tests/security/contentSecurityPolicy/1.1/module-scriptnonce-and-scripthash-expected.txt: Added.
>+        * http/tests/security/contentSecurityPolicy/1.1/module-scriptnonce-and-scripthash.html: Added.
>+        * http/tests/security/contentSecurityPolicy/1.1/module-scriptnonce-basic-blocked-expected.txt: Added.
>+        * http/tests/security/contentSecurityPolicy/1.1/module-scriptnonce-basic-blocked.html: Added.
>+        * http/tests/security/contentSecurityPolicy/1.1/module-scriptnonce-blocked-expected.txt: Added.
>+        * http/tests/security/contentSecurityPolicy/1.1/module-scriptnonce-blocked.html: Added.
>+        * http/tests/security/contentSecurityPolicy/1.1/module-scriptnonce-ignore-unsafeinline-expected.txt: Added.
>+        * http/tests/security/contentSecurityPolicy/1.1/module-scriptnonce-ignore-unsafeinline.html: Added.
>+        * http/tests/security/contentSecurityPolicy/1.1/module-scriptnonce-in-enforced-policy-and-not-in-report-only-expected.txt: Added.
>+        * http/tests/security/contentSecurityPolicy/1.1/module-scriptnonce-in-enforced-policy-and-not-in-report-only.html: Added.
>+        * http/tests/security/contentSecurityPolicy/1.1/module-scriptnonce-in-one-enforced-policy-neither-in-another-enforced-policy-nor-report-policy-expected.txt: Added.
>+        * http/tests/security/contentSecurityPolicy/1.1/module-scriptnonce-in-one-enforced-policy-neither-in-another-enforced-policy-nor-report-policy.html: Added.
>+        * http/tests/security/contentSecurityPolicy/1.1/module-scriptnonce-invalidnonce-expected.txt: Added.
>+        * http/tests/security/contentSecurityPolicy/1.1/module-scriptnonce-invalidnonce.html: Added.
>+        * http/tests/security/contentSecurityPolicy/1.1/module-scriptnonce-multiple-policies-expected.txt: Added.
>+        * http/tests/security/contentSecurityPolicy/1.1/module-scriptnonce-multiple-policies.html: Added.
>+        * http/tests/security/contentSecurityPolicy/1.1/module-scriptnonce-redirect-expected.txt: Added.
>+        * http/tests/security/contentSecurityPolicy/1.1/module-scriptnonce-redirect-same-origin-expected.txt: Added.
>+        * http/tests/security/contentSecurityPolicy/1.1/module-scriptnonce-redirect-same-origin.html: Added.
>+        * http/tests/security/contentSecurityPolicy/1.1/module-scriptnonce-redirect.html: Added.
>+        * http/tests/security/contentSecurityPolicy/1.1/resources/module-scriptnonce-in-enforced-policy-and-not-in-report-only.php: Added.
>+        * http/tests/security/contentSecurityPolicy/1.1/resources/module-scriptnonce-in-one-enforced-policy-neither-in-another-enforced-policy-nor-report-policy.php: Added.
>+        * http/tests/security/contentSecurityPolicy/resources/echo-module-script-src.pl: Added.
>+        * http/tests/security/contentSecurityPolicy/resources/multiple-iframe-module-test.js: Added.
>+        (testPreescapedPolicy):
>+        (testExperimentalPolicy):
>+        (test):
>+        (iframe.onload):
>+        (testImpl):
>+        (finishTesting):
>+        * http/tests/security/module-correct-mime-types-expected.txt: Added.
>+        * http/tests/security/module-correct-mime-types.html: Added.
>+        * http/tests/security/module-crossorigin-error-event-information-expected.txt: Added.
>+        * http/tests/security/module-crossorigin-error-event-information.html: Added.
>+        * http/tests/security/module-crossorigin-loads-correctly-credentials-expected.txt: Added.
>+        * http/tests/security/module-crossorigin-loads-correctly-credentials.html: Added.
>+        * http/tests/security/module-crossorigin-loads-omit-expected.txt: Added.
>+        * http/tests/security/module-crossorigin-loads-omit.html: Added.
>+        * http/tests/security/module-crossorigin-loads-same-origin-expected.txt: Added.
>+        * http/tests/security/module-crossorigin-loads-same-origin.html: Added.
>+        * http/tests/security/module-crossorigin-onerror-information-expected.txt: Added.
>+        * http/tests/security/module-crossorigin-onerror-information.html: Added.
>+        * http/tests/security/module-incorrect-mime-types-expected.txt: Added.
>+        * http/tests/security/module-incorrect-mime-types.html: Added.
>+        * http/tests/security/module-no-mime-type-expected.txt: Added.
>+        * http/tests/security/module-no-mime-type.html: Added.
>+        * http/tests/security/module-requires-javascript-mime-types-expected.txt: Added.
>+        * http/tests/security/module-requires-javascript-mime-types.html: Added.
>+        * http/tests/security/resources/cors-script.php:
>+        * js/dom/module-and-dom-content-loaded-expected.txt: Added.
>+        * js/dom/module-and-dom-content-loaded.html: Added.
>+        * js/dom/module-and-window-load-expected.txt: Added.
>+        * js/dom/module-and-window-load.html: Added.
>+        * js/dom/module-async-and-window-load-expected.txt: Added.
>+        * js/dom/module-async-and-window-load.html: Added.
>+        * js/dom/module-document-write-expected.txt: Added.
>+        * js/dom/module-document-write-src-expected.txt: Added.
>+        * js/dom/module-document-write-src.html: Added.
>+        * js/dom/module-document-write.html: Added.
>+        * js/dom/module-execution-error-inside-dependent-module-should-be-propagated-to-onerror-expected.txt: Added.
>+        * js/dom/module-execution-error-inside-dependent-module-should-be-propagated-to-onerror.html: Added.
>+        * js/dom/module-execution-error-should-be-propagated-to-onerror-expected.txt: Added.
>+        * js/dom/module-execution-error-should-be-propagated-to-onerror.html: Added.
>+        * js/dom/module-execution-order-inline-expected.txt: Added.
>+        * js/dom/module-execution-order-inline.html: Added.
>+        * js/dom/module-execution-order-mixed-expected.txt: Added.
>+        * js/dom/module-execution-order-mixed.html: Added.
>+        * js/dom/module-incorrect-relative-specifier-expected.txt: Added.
>+        * js/dom/module-incorrect-relative-specifier.html: Added.
>+        * js/dom/module-incorrect-tag-expected.txt: Added.
>+        * js/dom/module-incorrect-tag.html: Added.
>+        * js/dom/module-inline-current-script-expected.txt: Added.
>+        * js/dom/module-inline-current-script.html: Added.
>+        * js/dom/module-inline-dynamic-expected.txt: Added.
>+        * js/dom/module-inline-dynamic.html: Added.
>+        * js/dom/module-inline-simple-expected.txt: Added.
>+        * js/dom/module-inline-simple.html: Added.
>+        * js/dom/module-load-event-expected.txt: Added.
>+        * js/dom/module-load-event-with-src-expected.txt: Added.
>+        * js/dom/module-load-event-with-src.html: Added.
>+        * js/dom/module-load-event.html: Added.
>+        * js/dom/module-load-same-module-from-different-entry-point-dynamic-expected.txt: Added.
>+        * js/dom/module-load-same-module-from-different-entry-point-dynamic.html: Added.
>+        * js/dom/module-load-same-module-from-different-entry-point-expected.txt: Added.
>+        * js/dom/module-load-same-module-from-different-entry-point.html: Added.
>+        * js/dom/module-not-found-error-event-expected.txt: Added.
>+        * js/dom/module-not-found-error-event-with-src-and-import-expected.txt: Added.
>+        * js/dom/module-not-found-error-event-with-src-and-import.html: Added.
>+        * js/dom/module-not-found-error-event-with-src-expected.txt: Added.
>+        * js/dom/module-not-found-error-event-with-src.html: Added.
>+        * js/dom/module-not-found-error-event.html: Added.
>+        * js/dom/module-src-current-script-expected.txt: Added.
>+        * js/dom/module-src-current-script.html: Added.
>+        * js/dom/module-src-dynamic-expected.txt: Added.
>+        * js/dom/module-src-dynamic.html: Added.
>+        * js/dom/module-src-simple-expected.txt: Added.
>+        * js/dom/module-src-simple.html: Added.
>+        * js/dom/module-type-case-insensitive-expected.txt: Added.
>+        * js/dom/module-type-case-insensitive.html: Added.
>+        * js/dom/module-will-fire-beforeload-expected.txt: Added.
>+        * js/dom/module-will-fire-beforeload.html: Added.
>+        * js/dom/script-tests/module-document-write-src.js: Added.
>+        * js/dom/script-tests/module-execution-error-inside-dependent-module-should-be-propagated-to-onerror-throw.js: Added.
>+
> 2016-11-14  Joseph Pecoraro  <pecoraro@apple.com>
> 
>         Web Inspector: Worker debugging should pause all targets and view call frames in all targets
>diff --git a/LayoutTests/TestExpectations b/LayoutTests/TestExpectations
>index 97eefd9f4e8ebae93352d338f3ffe0b1acc4229f..5a6caafb1aebdcab202fdd3cbd12ee14952a4aa3 100644
>--- a/LayoutTests/TestExpectations
>+++ b/LayoutTests/TestExpectations
>@@ -985,3 +985,53 @@ webkit.org/b/164229 media/modern-media-controls/volume-support/volume-support-cl
> 
> webkit.org/b/164080 http/tests/websocket/tests/hybi/closed-when-entering-page-cache.html [ Pass Failure ]
> webkit.org/b/164080 http/tests/websocket/tests/hybi/stop-on-resume-in-error-handler.html [ Pass Failure ]
>+
>+# ES6 Modules are not yet enabled by default: ENABLE(ES6_MODULES)
>+# http/tests/misc/module-absolute-url.html [ Skip ]
>+# http/tests/misc/module-script-async.html [ Skip ]
>+# http/tests/security/contentSecurityPolicy/1.1/module-scriptnonce-allowed.html [ Skip ]
>+# http/tests/security/contentSecurityPolicy/1.1/module-scriptnonce-and-scripthash.html [ Skip ]
>+# http/tests/security/contentSecurityPolicy/1.1/module-scriptnonce-basic-blocked.html [ Skip ]
>+# http/tests/security/contentSecurityPolicy/1.1/module-scriptnonce-blocked.html [ Skip ]
>+# http/tests/security/contentSecurityPolicy/1.1/module-scriptnonce-ignore-unsafeinline.html [ Skip ]
>+# http/tests/security/contentSecurityPolicy/1.1/module-scriptnonce-in-enforced-policy-and-not-in-report-only.html [ Skip ]
>+# http/tests/security/contentSecurityPolicy/1.1/module-scriptnonce-in-one-enforced-policy-neither-in-another-enforced-policy-nor-report-policy.html [ Skip ]
>+# http/tests/security/contentSecurityPolicy/1.1/module-scriptnonce-invalidnonce.html [ Skip ]
>+# http/tests/security/contentSecurityPolicy/1.1/module-scriptnonce-multiple-policies.html [ Skip ]
>+# http/tests/security/contentSecurityPolicy/1.1/module-scriptnonce-redirect-same-origin.html [ Skip ]
>+# http/tests/security/contentSecurityPolicy/1.1/module-scriptnonce-redirect.html [ Skip ]
>+# http/tests/security/module-correct-mime-types.html [ Skip ]
>+# http/tests/security/module-crossorigin-loads-correctly-credentials.html [ Skip ]
>+# http/tests/security/module-crossorigin-loads-omit.html [ Skip ]
>+# http/tests/security/module-crossorigin-loads-same-origin.html [ Skip ]
>+# http/tests/security/module-incorrect-mime-types.html [ Skip ]
>+# http/tests/security/module-no-mime-type.html [ Skip ]
>+# http/tests/security/module-requires-javascript-mime-types.html [ Skip ]
>+# js/dom/module-and-dom-content-loaded.html [ Skip ]
>+# js/dom/module-and-window-load.html [ Skip ]
>+# js/dom/module-async-and-window-load.html [ Skip ]
>+# js/dom/module-document-write-src.html [ Skip ]
>+# js/dom/module-document-write.html [ Skip ]
>+# js/dom/module-execution-error-inside-dependent-module-should-be-propagated-to-onerror.html [ Skip ]
>+# js/dom/module-execution-error-should-be-propagated-to-onerror.html [ Skip ]
>+# js/dom/module-execution-order-inline.html [ Skip ]
>+# js/dom/module-execution-order-mixed.html [ Skip ]
>+# js/dom/module-incorrect-relative-specifier.html [ Skip ]
>+# js/dom/module-incorrect-tag.html [ Skip ]
>+# js/dom/module-inline-current-script.html [ Skip ]
>+# js/dom/module-inline-dynamic.html [ Skip ]
>+# js/dom/module-inline-simple.html [ Skip ]
>+# js/dom/module-load-event-with-src.html [ Skip ]
>+# js/dom/module-load-event.html [ Skip ]
>+# js/dom/module-load-same-module-from-different-entry-point-dynamic.html [ Skip ]
>+# js/dom/module-load-same-module-from-different-entry-point.html [ Skip ]
>+# js/dom/module-not-found-error-event-with-src-and-import.html [ Skip ]
>+# js/dom/module-not-found-error-event-with-src.html [ Skip ]
>+# js/dom/module-not-found-error-event.html [ Skip ]
>+# js/dom/module-src-current-script.html [ Skip ]
>+# js/dom/module-src-dynamic.html [ Skip ]
>+# js/dom/module-src-simple.html [ Skip ]
>+# js/dom/module-type-case-insensitive.html [ Skip ]
>+# js/dom/module-will-fire-beforeload.html [ Skip ]
>+webkit.org/b/164539 http/tests/security/module-crossorigin-error-event-information.html [ Failure ]
>+webkit.org/b/164539 http/tests/security/module-crossorigin-onerror-information.html [ Failure ]
>diff --git a/LayoutTests/http/tests/misc/module-absolute-url-expected.txt b/LayoutTests/http/tests/misc/module-absolute-url-expected.txt
>new file mode 100644
>index 0000000000000000000000000000000000000000..ce5106eaa5458e324e5abfe191d351b020f2a53f
>--- /dev/null
>+++ b/LayoutTests/http/tests/misc/module-absolute-url-expected.txt
>@@ -0,0 +1,7 @@
>+Test modules with absolute URLs.
>+http://127.0.0.1:8000/misc/resources/module-absolute-url2.js
>+http://127.0.0.1:8000/misc/resources/module-absolute-url.js
>+PASS successfullyParsed is true
>+
>+TEST COMPLETE
>+
>diff --git a/LayoutTests/http/tests/misc/module-absolute-url.html b/LayoutTests/http/tests/misc/module-absolute-url.html
>new file mode 100644
>index 0000000000000000000000000000000000000000..0910edf0eecc92c99696d4651b628584d480137d
>--- /dev/null
>+++ b/LayoutTests/http/tests/misc/module-absolute-url.html
>@@ -0,0 +1,19 @@
>+<!DOCTYPE HTML>
>+<html>
>+<head>
>+<meta charset="UTF-8">
>+<script src="../../js-test-resources/js-test-pre.js"></script>
>+</head>
>+<body onload="test()">
>+Test modules with absolute URLs.<hr>
>+<div id="console"></div>
>+<script>
>+var jsTestIsAsync = true;
>+</script>
>+<script type="module">
>+import "http://127.0.0.1:8000/misc/resources/module-absolute-url.js";
>+finishJSTest();
>+</script>
>+<script src="../../js-test-resources/js-test-post.js"></script>
>+</body>
>+</html>
>diff --git a/LayoutTests/http/tests/misc/module-script-async-expected.txt b/LayoutTests/http/tests/misc/module-script-async-expected.txt
>new file mode 100644
>index 0000000000000000000000000000000000000000..07ddedef660eddb289f6829d65dab695e9ff6d43
>--- /dev/null
>+++ b/LayoutTests/http/tests/misc/module-script-async-expected.txt
>@@ -0,0 +1,2 @@
>+This tests for proper execution order of module scripts with the async attribute.
>+PASS
>diff --git a/LayoutTests/http/tests/misc/module-script-async.html b/LayoutTests/http/tests/misc/module-script-async.html
>new file mode 100644
>index 0000000000000000000000000000000000000000..d18988a134d49d3637f1950866f55c04e9a92ae6
>--- /dev/null
>+++ b/LayoutTests/http/tests/misc/module-script-async.html
>@@ -0,0 +1,48 @@
>+<!DOCTYPE HTML>
>+<html>
>+<head>
>+<meta charset="UTF-8">
>+<script src="../../js-test-resources/js-test-pre.js"></script>
>+</head>
>+<body onload="test()">
>+This tests for proper execution order of module scripts with the async attribute.<hr>
>+<div id="console"></div>
>+<script type="text/javascript">
>+var jsTestIsAsync = true;
>+
>+function debug(msg)
>+{
>+    if (!window.status_)
>+        window.status_ = '';
>+    window.status_ += ' ' + msg + ' ';
>+}
>+
>+document.addEventListener("DOMContentLoaded", function() {
>+    debug('DOMContentLoaded');
>+}, false);
>+
>+function test()
>+{
>+    var expectedA = " async  external  inline  DOMContentLoaded  slowAsync ";
>+    var expectedB = " external  async  inline  DOMContentLoaded  slowAsync ";
>+    var expectedC = " external  inline  async  DOMContentLoaded  slowAsync ";
>+    var expectedD = " external  inline  DOMContentLoaded  async  slowAsync ";
>+    var results = "PASS";
>+    if (window.status_ != expectedA && window.status_ != expectedB && window.status_ != expectedC && window.status_ != expectedD)
>+        results = "FAIL: Expected one of '" + expectedA + "' || '" + expectedB + "' || '" + expectedC + "' || '" + expectedD + "', Actual='" + window.status_ + "'";
>+    document.getElementById("console").innerHTML = results;
>+    finishJSTest();
>+}
>+
>+</script>
>+<script type="module" src="http://127.0.0.1:8000/misc/resources/slow-async-script.cgi" async="ASYNC"></script>
>+<script type="module" src="http://127.0.0.1:8000/misc/resources/async-script.js" async="ASYNC"></script>
>+<script src="http://127.0.0.1:8000/misc/resources/external-script.js"></script>
>+<script>
>+debug("inline");
>+</script>
>+<script src="../../js-test-resources/js-test-post.js"></script>
>+</body>
>+</html>
>+
>+
>diff --git a/LayoutTests/http/tests/misc/resources/module-absolute-url.js b/LayoutTests/http/tests/misc/resources/module-absolute-url.js
>new file mode 100644
>index 0000000000000000000000000000000000000000..d5e1c3c302f1830229e1a9656c62457ba59ad07b
>--- /dev/null
>+++ b/LayoutTests/http/tests/misc/resources/module-absolute-url.js
>@@ -0,0 +1,3 @@
>+import "http://127.0.0.1:8000/misc/resources/module-absolute-url2.js";
>+
>+debug("http://127.0.0.1:8000/misc/resources/module-absolute-url.js");
>diff --git a/LayoutTests/http/tests/misc/resources/module-absolute-url2.js b/LayoutTests/http/tests/misc/resources/module-absolute-url2.js
>new file mode 100644
>index 0000000000000000000000000000000000000000..d414ee2858de12f548344a814ddfb4689a329566
>--- /dev/null
>+++ b/LayoutTests/http/tests/misc/resources/module-absolute-url2.js
>@@ -0,0 +1 @@
>+debug("http://127.0.0.1:8000/misc/resources/module-absolute-url2.js");
>diff --git a/LayoutTests/http/tests/security/contentSecurityPolicy/1.1/module-scriptnonce-allowed-expected.txt b/LayoutTests/http/tests/security/contentSecurityPolicy/1.1/module-scriptnonce-allowed-expected.txt
>new file mode 100644
>index 0000000000000000000000000000000000000000..0d21037f987a405bcbe70bd9bc8b333e886e23e9
>--- /dev/null
>+++ b/LayoutTests/http/tests/security/contentSecurityPolicy/1.1/module-scriptnonce-allowed-expected.txt
>@@ -0,0 +1,6 @@
>+ALERT: PASS (1/3)
>+ALERT: PASS (2/3)
>+ALERT: PASS (3/3)
>+This tests the effect of a valid module script-nonce value. It passes if no console warning is visible and the alerts are executed.
>+
>+PASS
>diff --git a/LayoutTests/http/tests/security/contentSecurityPolicy/1.1/module-scriptnonce-allowed.html b/LayoutTests/http/tests/security/contentSecurityPolicy/1.1/module-scriptnonce-allowed.html
>new file mode 100644
>index 0000000000000000000000000000000000000000..50f3f2c4017059a2800c1aa0fb4c6e4b48c19b4f
>--- /dev/null
>+++ b/LayoutTests/http/tests/security/contentSecurityPolicy/1.1/module-scriptnonce-allowed.html
>@@ -0,0 +1,37 @@
>+<!DOCTYPE html>
>+<html>
>+    <head>
>+        <meta http-equiv="Content-Security-Policy" content="script-src 'nonce-noncynonce' 'nonce-noncy+/=nonce'">
>+        <script nonce="noncynonce">
>+        if (window.testRunner) {
>+            testRunner.dumpAsText();
>+            testRunner.waitUntilDone();
>+        }
>+
>+        function done(msg) {
>+            document.querySelector("pre").innerHTML = msg;
>+            if (window.testRunner)
>+                testRunner.notifyDone();
>+        }
>+        </script>
>+        <script type="module" nonce="noncynonce">
>+            alert('PASS (1/3)');
>+        </script>
>+        <script type="module" nonce="noncynonce">
>+            alert('PASS (2/3)');
>+        </script>
>+        <script type="module" nonce="noncy+/=nonce">
>+            alert('PASS (3/3)');
>+        </script>
>+        <script type="module" nonce="noncynonce">
>+            done("PASS");
>+        </script>
>+    </head>
>+    <body>
>+        <p>
>+            This tests the effect of a valid module script-nonce value. It passes if
>+            no console warning is visible and the alerts are executed.
>+        </p>
>+        <pre></pre>
>+    </body>
>+</html>
>diff --git a/LayoutTests/http/tests/security/contentSecurityPolicy/1.1/module-scriptnonce-and-scripthash-expected.txt b/LayoutTests/http/tests/security/contentSecurityPolicy/1.1/module-scriptnonce-and-scripthash-expected.txt
>new file mode 100644
>index 0000000000000000000000000000000000000000..d9ae618327d67961f50959e6745b5a2fa5231af7
>--- /dev/null
>+++ b/LayoutTests/http/tests/security/contentSecurityPolicy/1.1/module-scriptnonce-and-scripthash-expected.txt
>@@ -0,0 +1,8 @@
>+ALERT: PASS (1/3)
>+CONSOLE MESSAGE: line 25: Refused to execute a script because its hash, its nonce, or 'unsafe-inline' does not appear in the script-src directive of the Content Security Policy.
>+CONSOLE MESSAGE: line 28: Refused to execute a script because its hash, its nonce, or 'unsafe-inline' does not appear in the script-src directive of the Content Security Policy.
>+ALERT: PASS (2/3)
>+ALERT: PASS (3/3)
>+This tests the combined use of script hash and script nonce. It passes if two console warnings are visible and the three alerts show PASS.
>+
>+PASS
>diff --git a/LayoutTests/http/tests/security/contentSecurityPolicy/1.1/module-scriptnonce-and-scripthash.html b/LayoutTests/http/tests/security/contentSecurityPolicy/1.1/module-scriptnonce-and-scripthash.html
>new file mode 100644
>index 0000000000000000000000000000000000000000..6e6c294d73aebbab4d9df4659d9e3a22b9d218e1
>--- /dev/null
>+++ b/LayoutTests/http/tests/security/contentSecurityPolicy/1.1/module-scriptnonce-and-scripthash.html
>@@ -0,0 +1,40 @@
>+<!DOCTYPE html>
>+<html>
>+    <head>
>+        <meta http-equiv="Content-Security-Policy" content="script-src 'sha256-n8xN1Y8E6rPXuE8Iv++3Y3Smm6W4OGH6gqfZV7H8F1E=' 'nonce-nonceynonce'">
>+        <script nonce="nonceynonce">
>+            if (window.testRunner) {
>+                testRunner.dumpAsText();
>+                testRunner.waitUntilDone();
>+            }
>+
>+            function done(msg) {
>+                document.querySelector("pre").innerHTML = msg;
>+                if (window.testRunner)
>+                    testRunner.notifyDone();
>+            }
>+            alert('PASS (1/3)');
>+        </script>
>+        <script type="module">
>+            alert('PASS (2/3)');
>+        </script>
>+        <script type="module" nonce="nonceynonce">
>+            alert('PASS (3/3)');
>+            done("PASS");
>+        </script>
>+        <script type="module">
>+            alert('FAIL (1/2)');
>+        </script>
>+        <script type="module" nonce="notanonce">
>+            alert('FAIL (2/2)');
>+        </script>
>+    </head>
>+    <body>
>+        <p>
>+            This tests the combined use of script hash and script nonce. It
>+            passes if two console warnings are visible and the three alerts show
>+            PASS.
>+        </p>
>+        <pre></pre>
>+    </body>
>+</html>
>diff --git a/LayoutTests/http/tests/security/contentSecurityPolicy/1.1/module-scriptnonce-basic-blocked-expected.txt b/LayoutTests/http/tests/security/contentSecurityPolicy/1.1/module-scriptnonce-basic-blocked-expected.txt
>new file mode 100644
>index 0000000000000000000000000000000000000000..e65105b728493a5da392821612f1f57d393a1456
>--- /dev/null
>+++ b/LayoutTests/http/tests/security/contentSecurityPolicy/1.1/module-scriptnonce-basic-blocked-expected.txt
>@@ -0,0 +1,8 @@
>+ALERT: PASS (1/2)
>+CONSOLE MESSAGE: line 21: Refused to execute a script because its hash, its nonce, or 'unsafe-inline' does not appear in the script-src directive of the Content Security Policy.
>+CONSOLE MESSAGE: line 24: Refused to execute a script because its hash, its nonce, or 'unsafe-inline' does not appear in the script-src directive of the Content Security Policy.
>+CONSOLE MESSAGE: line 27: Refused to execute a script because its hash, its nonce, or 'unsafe-inline' does not appear in the script-src directive of the Content Security Policy.
>+ALERT: PASS (2/2)
>+This tests the effect of a valid script-nonce value. It passes if three console warnings are visible, and the two PASS alerts are executed.
>+
>+PASS
>diff --git a/LayoutTests/http/tests/security/contentSecurityPolicy/1.1/module-scriptnonce-basic-blocked.html b/LayoutTests/http/tests/security/contentSecurityPolicy/1.1/module-scriptnonce-basic-blocked.html
>new file mode 100644
>index 0000000000000000000000000000000000000000..0b84ad82e13abed5b99da081a3ac63f794a7942a
>--- /dev/null
>+++ b/LayoutTests/http/tests/security/contentSecurityPolicy/1.1/module-scriptnonce-basic-blocked.html
>@@ -0,0 +1,42 @@
>+<!DOCTYPE html>
>+<html>
>+    <head>
>+        <meta http-equiv="Content-Security-Policy" content="script-src 'nonce-noncynonce'">
>+        <script nonce="noncynonce">
>+        if (window.testRunner) {
>+            testRunner.dumpAsText();
>+            testRunner.waitUntilDone();
>+        }
>+
>+        function done(msg) {
>+            document.querySelector("pre").innerHTML = msg;
>+            if (window.testRunner)
>+                testRunner.notifyDone();
>+        }
>+        alert('PASS (1/2)');
>+        </script>
>+        <script type="module" nonce="   noncynonce    ">
>+        alert('PASS (2/2)');
>+        </script>
>+        <script type="module" nonce="noncynonce noncynonce">
>+            alert('FAIL (1/3)');
>+        </script>
>+        <script type="module">
>+            alert('FAIL (2/3)');
>+        </script>
>+        <script type="module" nonce="noncynonceno?">
>+            alert('FAIL (3/3)');
>+        </script>
>+        <script type="module" nonce="noncynonce">
>+            done("PASS");
>+        </script>
>+    </head>
>+    <body>
>+        <p>
>+            This tests the effect of a valid script-nonce value. It passes if
>+            three console warnings are visible, and the two PASS alerts are
>+            executed.
>+        </p>
>+        <pre></pre>
>+    </body>
>+</html>
>diff --git a/LayoutTests/http/tests/security/contentSecurityPolicy/1.1/module-scriptnonce-blocked-expected.txt b/LayoutTests/http/tests/security/contentSecurityPolicy/1.1/module-scriptnonce-blocked-expected.txt
>new file mode 100644
>index 0000000000000000000000000000000000000000..b1d0f4bcbd95ce6359003e504e1227b2a058d365
>--- /dev/null
>+++ b/LayoutTests/http/tests/security/contentSecurityPolicy/1.1/module-scriptnonce-blocked-expected.txt
>@@ -0,0 +1,30 @@
>+CONSOLE MESSAGE: Refused to load http://127.0.0.1:8000/security/contentSecurityPolicy/resources/script.js because it does not appear in the script-src directive of the Content Security Policy.
>+CONSOLE MESSAGE: Refused to load http://127.0.0.1:8000/security/contentSecurityPolicy/resources/script.js because it does not appear in the script-src directive of the Content Security Policy.
>+Only the first two of these scripts should execute even though there are parse errors in the policy.
>+
>+
>+
>+--------
>+Frame: '-->'
>+--------
>+PASS
>+
>+--------
>+Frame: '-->'
>+--------
>+PASS
>+
>+--------
>+Frame: '-->'
>+--------
>+PASS
>+
>+--------
>+Frame: '-->'
>+--------
>+PASS
>+
>+--------
>+Frame: '-->'
>+--------
>+PASS
>diff --git a/LayoutTests/http/tests/security/contentSecurityPolicy/1.1/module-scriptnonce-blocked.html b/LayoutTests/http/tests/security/contentSecurityPolicy/1.1/module-scriptnonce-blocked.html
>new file mode 100644
>index 0000000000000000000000000000000000000000..7ecba1b3b946ad518907da2b17b7ab6ee642fec4
>--- /dev/null
>+++ b/LayoutTests/http/tests/security/contentSecurityPolicy/1.1/module-scriptnonce-blocked.html
>@@ -0,0 +1,18 @@
>+<!DOCTYPE html>
>+<html>
>+<head>
>+<script src='../resources/multiple-iframe-module-test.js'></script>
>+<script>
>+var tests = [
>+    ['yes', 'script-src 127.0.0.1:8000', 'resources/script.js', 'nonce'],
>+    ['yes', 'script-src 127.0.0.1:8000 \'nonce-nonce\'', 'resources/script.js', 'nonce'],
>+    ['yes', 'script-src 127.0.0.1:8000 \'nonce-base64has+and/characters\'', 'resources/script.js', 'base64has+and/characters'],
>+    ['no', 'script-src \'nonce-nonce\'', 'resources/script.js', 'notnonce'],
>+    ['no', 'script-src \'nonce-notnonce\'', 'resources/script.js', 'nonce'],
>+];
>+</script>
>+</head>
>+<body onload="testExperimentalPolicy()">
>+  <p>
>+    Only the first two of these scripts should execute even though there are parse errors in the policy.
>+  </p>
>diff --git a/LayoutTests/http/tests/security/contentSecurityPolicy/1.1/module-scriptnonce-ignore-unsafeinline-expected.txt b/LayoutTests/http/tests/security/contentSecurityPolicy/1.1/module-scriptnonce-ignore-unsafeinline-expected.txt
>new file mode 100644
>index 0000000000000000000000000000000000000000..96ab58cfd50ca7b97884b09291c47011034cbdfa
>--- /dev/null
>+++ b/LayoutTests/http/tests/security/contentSecurityPolicy/1.1/module-scriptnonce-ignore-unsafeinline-expected.txt
>@@ -0,0 +1,6 @@
>+CONSOLE MESSAGE: line 24: Refused to execute a script because its hash, its nonce, or 'unsafe-inline' does not appear in the script-src directive of the Content Security Policy.
>+ALERT: PASS (1/2)
>+ALERT: PASS (2/2)
>+This tests that a valid nonce disables inline JavaScript, even if 'unsafe-inline' is present.
>+
>+PASS
>diff --git a/LayoutTests/http/tests/security/contentSecurityPolicy/1.1/module-scriptnonce-ignore-unsafeinline.html b/LayoutTests/http/tests/security/contentSecurityPolicy/1.1/module-scriptnonce-ignore-unsafeinline.html
>new file mode 100644
>index 0000000000000000000000000000000000000000..545ea9682a52a716ca01e33809fd06e2e51405bb
>--- /dev/null
>+++ b/LayoutTests/http/tests/security/contentSecurityPolicy/1.1/module-scriptnonce-ignore-unsafeinline.html
>@@ -0,0 +1,34 @@
>+<!DOCTYPE html>
>+<html>
>+    <head>
>+        <meta http-equiv="Content-Security-Policy" content="script-src 'nonce-noncynonce' 'nonce-noncy+/=nonce' 'unsafe-inline'">
>+        <script nonce="noncynonce">
>+        if (window.testRunner) {
>+            testRunner.dumpAsText();
>+            testRunner.waitUntilDone();
>+        }
>+
>+        function done(msg) {
>+            document.querySelector("pre").innerHTML = msg;
>+            if (window.testRunner)
>+                testRunner.notifyDone();
>+        }
>+        </script>
>+        <script type="module" nonce="noncynonce">
>+            alert('PASS (1/2)');
>+        </script>
>+        <script type="module" nonce="noncy+/=nonce">
>+            alert('PASS (2/2)');
>+            done("PASS");
>+        </script>
>+        <script type="module">
>+            alert('FAIL (1/1)');
>+        </script>
>+    </head>
>+    <body>
>+        <p>
>+            This tests that a valid nonce disables inline JavaScript, even if 'unsafe-inline' is present.
>+        </p>
>+        <pre></pre>
>+    </body>
>+</html>
>diff --git a/LayoutTests/http/tests/security/contentSecurityPolicy/1.1/module-scriptnonce-in-enforced-policy-and-not-in-report-only-expected.txt b/LayoutTests/http/tests/security/contentSecurityPolicy/1.1/module-scriptnonce-in-enforced-policy-and-not-in-report-only-expected.txt
>new file mode 100644
>index 0000000000000000000000000000000000000000..e184d35b0c68bcbee70d9bed3dc5c7f6d0766574
>--- /dev/null
>+++ b/LayoutTests/http/tests/security/contentSecurityPolicy/1.1/module-scriptnonce-in-enforced-policy-and-not-in-report-only-expected.txt
>@@ -0,0 +1,11 @@
>+CONSOLE MESSAGE: The Content Security Policy 'script-src 'none'' was delivered in report-only mode, but does not specify a 'report-uri'; the policy will have no effect. Please either add a 'report-uri' directive, or deliver the policy via the 'Content-Security-Policy' header.
>+CONSOLE MESSAGE: line 11: [Report Only] Refused to execute a script because its hash, its nonce, or 'unsafe-inline' does not appear in the script-src directive of the Content Security Policy.
>+CONSOLE MESSAGE: line 11: Refused to execute a script because its hash, its nonce, or 'unsafe-inline' does not appear in the script-src directive of the Content Security Policy.
>+
>+
>+--------
>+Frame: '-->'
>+--------
>+PASS did execute script with nonce.
>+
>+PASS did not execute script without nonce.
>diff --git a/LayoutTests/http/tests/security/contentSecurityPolicy/1.1/module-scriptnonce-in-enforced-policy-and-not-in-report-only.html b/LayoutTests/http/tests/security/contentSecurityPolicy/1.1/module-scriptnonce-in-enforced-policy-and-not-in-report-only.html
>new file mode 100644
>index 0000000000000000000000000000000000000000..edb4dd932d0223df9faf87f5b2f5d76e0f269132
>--- /dev/null
>+++ b/LayoutTests/http/tests/security/contentSecurityPolicy/1.1/module-scriptnonce-in-enforced-policy-and-not-in-report-only.html
>@@ -0,0 +1,15 @@
>+<!DOCTYPE html>
>+<html>
>+<head>
>+<script>
>+if (window.testRunner) {
>+    testRunner.dumpAsText();
>+    testRunner.dumpChildFramesAsText();
>+    testRunner.waitUntilDone();
>+}
>+</script>
>+</head>
>+<body>
>+<iframe src="resources/module-scriptnonce-in-enforced-policy-and-not-in-report-only.php"></iframe>
>+</body>
>+</html>
>diff --git a/LayoutTests/http/tests/security/contentSecurityPolicy/1.1/module-scriptnonce-in-one-enforced-policy-neither-in-another-enforced-policy-nor-report-policy-expected.txt b/LayoutTests/http/tests/security/contentSecurityPolicy/1.1/module-scriptnonce-in-one-enforced-policy-neither-in-another-enforced-policy-nor-report-policy-expected.txt
>new file mode 100644
>index 0000000000000000000000000000000000000000..5613fa5d10f365b039ea60a1ecde97170743078a
>--- /dev/null
>+++ b/LayoutTests/http/tests/security/contentSecurityPolicy/1.1/module-scriptnonce-in-one-enforced-policy-neither-in-another-enforced-policy-nor-report-policy-expected.txt
>@@ -0,0 +1,7 @@
>+CONSOLE MESSAGE: The Content Security Policy 'object-src 'none'' was delivered in report-only mode, but does not specify a 'report-uri'; the policy will have no effect. Please either add a 'report-uri' directive, or deliver the policy via the 'Content-Security-Policy' header.
>+
>+
>+--------
>+Frame: '-->'
>+--------
>+PASS did execute script.
>diff --git a/LayoutTests/http/tests/security/contentSecurityPolicy/1.1/module-scriptnonce-in-one-enforced-policy-neither-in-another-enforced-policy-nor-report-policy.html b/LayoutTests/http/tests/security/contentSecurityPolicy/1.1/module-scriptnonce-in-one-enforced-policy-neither-in-another-enforced-policy-nor-report-policy.html
>new file mode 100644
>index 0000000000000000000000000000000000000000..c34b220d7ad97242385c5225278f2f6efa2a3489
>--- /dev/null
>+++ b/LayoutTests/http/tests/security/contentSecurityPolicy/1.1/module-scriptnonce-in-one-enforced-policy-neither-in-another-enforced-policy-nor-report-policy.html
>@@ -0,0 +1,15 @@
>+<!DOCTYPE html>
>+<html>
>+<head>
>+<script>
>+if (window.testRunner) {
>+    testRunner.dumpAsText();
>+    testRunner.dumpChildFramesAsText();
>+    testRunner.waitUntilDone();
>+}
>+</script>
>+</head>
>+<body>
>+<iframe src="resources/module-scriptnonce-in-one-enforced-policy-neither-in-another-enforced-policy-nor-report-policy.php"></iframe>
>+</body>
>+</html>
>diff --git a/LayoutTests/http/tests/security/contentSecurityPolicy/1.1/module-scriptnonce-invalidnonce-expected.txt b/LayoutTests/http/tests/security/contentSecurityPolicy/1.1/module-scriptnonce-invalidnonce-expected.txt
>new file mode 100644
>index 0000000000000000000000000000000000000000..d07866043854329589a2b0bd93f6b17560ff5f4f
>--- /dev/null
>+++ b/LayoutTests/http/tests/security/contentSecurityPolicy/1.1/module-scriptnonce-invalidnonce-expected.txt
>@@ -0,0 +1,75 @@
>+CONSOLE MESSAGE: The source list for Content Security Policy directive 'script-src' contains an invalid source: ''n'. It will be ignored.
>+CONSOLE MESSAGE: Refused to load http://127.0.0.1:8000/security/contentSecurityPolicy/resources/script.js because it does not appear in the script-src directive of the Content Security Policy.
>+CONSOLE MESSAGE: The source list for Content Security Policy directive 'script-src' contains an invalid source: ''nonce'. It will be ignored.
>+CONSOLE MESSAGE: Refused to load http://127.0.0.1:8000/security/contentSecurityPolicy/resources/script.js because it does not appear in the script-src directive of the Content Security Policy.
>+CONSOLE MESSAGE: The source list for Content Security Policy directive 'script-src' contains an invalid source: ''nonce-''. It will be ignored.
>+CONSOLE MESSAGE: Refused to load http://127.0.0.1:8000/security/contentSecurityPolicy/resources/script.js because it does not appear in the script-src directive of the Content Security Policy.
>+CONSOLE MESSAGE: The source list for Content Security Policy directive 'script-src' contains an invalid source: ''nonce-'. It will be ignored.
>+CONSOLE MESSAGE: Refused to load http://127.0.0.1:8000/security/contentSecurityPolicy/resources/script.js because it does not appear in the script-src directive of the Content Security Policy.
>+CONSOLE MESSAGE: Refused to load http://127.0.0.1:8000/security/contentSecurityPolicy/resources/script.js because it does not appear in the script-src directive of the Content Security Policy.
>+CONSOLE MESSAGE: The source list for Content Security Policy directive 'script-src' contains an invalid source: ''nonce-'. It will be ignored.
>+CONSOLE MESSAGE: The source list for Content Security Policy directive 'script-src' contains an invalid source: '''. It will be ignored.
>+CONSOLE MESSAGE: Refused to load http://127.0.0.1:8000/security/contentSecurityPolicy/resources/script.js because it does not appear in the script-src directive of the Content Security Policy.
>+CONSOLE MESSAGE: The source list for Content Security Policy directive 'script-src' contains an invalid source: ''nonce-'. It will be ignored.
>+CONSOLE MESSAGE: The source list for Content Security Policy directive 'script-src' contains an invalid source: '''. It will be ignored.
>+CONSOLE MESSAGE: Refused to load http://127.0.0.1:8000/security/contentSecurityPolicy/resources/script.js because it does not appear in the script-src directive of the Content Security Policy.
>+CONSOLE MESSAGE: The source list for Content Security Policy directive 'script-src' contains an invalid source: ''nonce-'. It will be ignored.
>+CONSOLE MESSAGE: The source list for Content Security Policy directive 'script-src' contains an invalid source: 'spaces''. It will be ignored.
>+CONSOLE MESSAGE: Refused to load http://127.0.0.1:8000/security/contentSecurityPolicy/resources/script.js because it does not appear in the script-src directive of the Content Security Policy.
>+CONSOLE MESSAGE: The source list for Content Security Policy directive 'script-src' contains an invalid source: ''nonce-{}''. It will be ignored.
>+CONSOLE MESSAGE: Refused to load http://127.0.0.1:8000/security/contentSecurityPolicy/resources/script.js because it does not appear in the script-src directive of the Content Security Policy.
>+CONSOLE MESSAGE: The source list for Content Security Policy directive 'script-src' contains an invalid source: ''nonce-/\''. It will be ignored.
>+CONSOLE MESSAGE: Refused to load http://127.0.0.1:8000/security/contentSecurityPolicy/resources/script.js because it does not appear in the script-src directive of the Content Security Policy.
>+None of these scripts should execute, as all the nonces are invalid.
>+
>+
>+
>+--------
>+Frame: '-->'
>+--------
>+PASS
>+
>+--------
>+Frame: '-->'
>+--------
>+PASS
>+
>+--------
>+Frame: '-->'
>+--------
>+PASS
>+
>+--------
>+Frame: '-->'
>+--------
>+PASS
>+
>+--------
>+Frame: '-->'
>+--------
>+PASS
>+
>+--------
>+Frame: '-->'
>+--------
>+PASS
>+
>+--------
>+Frame: '-->'
>+--------
>+PASS
>+
>+--------
>+Frame: '-->'
>+--------
>+PASS
>+
>+--------
>+Frame: '-->'
>+--------
>+PASS
>+
>+--------
>+Frame: '-->'
>+--------
>+PASS
>diff --git a/LayoutTests/http/tests/security/contentSecurityPolicy/1.1/module-scriptnonce-invalidnonce.html b/LayoutTests/http/tests/security/contentSecurityPolicy/1.1/module-scriptnonce-invalidnonce.html
>new file mode 100644
>index 0000000000000000000000000000000000000000..840518f512cfb846e37247d59782450831cf4e39
>--- /dev/null
>+++ b/LayoutTests/http/tests/security/contentSecurityPolicy/1.1/module-scriptnonce-invalidnonce.html
>@@ -0,0 +1,23 @@
>+<!DOCTYPE html>
>+<html>
>+<head>
>+<script src='../resources/multiple-iframe-module-test.js'></script>
>+<script>
>+var tests = [
>+    ['no', 'script-src \'n', 'resources/script.js', ''],
>+    ['no', 'script-src \'nonce', 'resources/script.js', ''],
>+    ['no', 'script-src \'nonce-\'', 'resources/script.js', ''],
>+    ['no', 'script-src \'nonce-', 'resources/script.js', ''],
>+    ['no', 'script-src nonce-abcd', 'resources/script.js', ''],
>+    ['no', 'script-src \'nonce- \'', 'resources/script.js', ''],
>+    ['no', 'script-src \'nonce-     \'', 'resources/script.js', ''],
>+    ['no', 'script-src \'nonce- nonces have no spaces\'', 'resources/script.js', ''],
>+    ['no', 'script-src \'nonce-{}\'', 'resources/script.js', '{}'],
>+    ['no', 'script-src \'nonce-/\\\'', 'resources/script.js', '/\\'],
>+];
>+</script>
>+</head>
>+<body onload="testExperimentalPolicy()">
>+  <p>
>+      None of these scripts should execute, as all the nonces are invalid.
>+  </p>
>diff --git a/LayoutTests/http/tests/security/contentSecurityPolicy/1.1/module-scriptnonce-multiple-policies-expected.txt b/LayoutTests/http/tests/security/contentSecurityPolicy/1.1/module-scriptnonce-multiple-policies-expected.txt
>new file mode 100644
>index 0000000000000000000000000000000000000000..ec7a228b06a7c3e0c9d7864176029436c57fe5cd
>--- /dev/null
>+++ b/LayoutTests/http/tests/security/contentSecurityPolicy/1.1/module-scriptnonce-multiple-policies-expected.txt
>@@ -0,0 +1,6 @@
>+CONSOLE MESSAGE: line 15: Refused to execute a script because its hash, its nonce, or 'unsafe-inline' does not appear in the script-src directive of the Content Security Policy.
>+CONSOLE MESSAGE: line 15: Refused to execute a script because its hash, its nonce, or 'unsafe-inline' does not appear in the script-src directive of the Content Security Policy.
>+CONSOLE MESSAGE: line 16: Refused to execute a script because its hash, its nonce, or 'unsafe-inline' does not appear in the script-src directive of the Content Security Policy.
>+CONSOLE MESSAGE: line 16: Refused to execute a script because its hash, its nonce, or 'unsafe-inline' does not appear in the script-src directive of the Content Security Policy.
>+ALERT: PASS
>+Tests that an inline script is allowed to execute only if its nonce appears in all policies. This test PASSED if there are two console warnings and a JavaScript alert with message PASS. Otherwise, it FAILED.
>diff --git a/LayoutTests/http/tests/security/contentSecurityPolicy/1.1/module-scriptnonce-multiple-policies.html b/LayoutTests/http/tests/security/contentSecurityPolicy/1.1/module-scriptnonce-multiple-policies.html
>new file mode 100644
>index 0000000000000000000000000000000000000000..6cd02e40f84b1ab695d6a132385745d86d53892c
>--- /dev/null
>+++ b/LayoutTests/http/tests/security/contentSecurityPolicy/1.1/module-scriptnonce-multiple-policies.html
>@@ -0,0 +1,23 @@
>+<!DOCTYPE html>
>+<html>
>+<head>
>+<script>
>+if (window.testRunner) {
>+    testRunner.dumpAsText();
>+    testRunner.waitUntilDone();
>+}
>+</script>
>+<meta http-equiv="Content-Security-Policy" content="script-src 'nonce-A' 'nonce-C'">
>+<meta http-equiv="Content-Security-Policy" content="script-src 'nonce-B' 'nonce-C'">
>+</head>
>+<body>
>+<p>Tests that an inline script is allowed to execute only if its nonce appears in all policies. This test PASSED if there are two console warnings and a JavaScript alert with message PASS. Otherwise, it FAILED.</p>
>+<script type="module" nonce="A">alert("FAIL did execute first script")</script>
>+<script type="module" nonce="B">alert("FAIL did execute second script")</script>
>+<script type="module" nonce="C">
>+alert("PASS");
>+if (window.testRunner)
>+    testRunner.notifyDone();
>+</script>
>+</body>
>+</html>
>diff --git a/LayoutTests/http/tests/security/contentSecurityPolicy/1.1/module-scriptnonce-redirect-expected.txt b/LayoutTests/http/tests/security/contentSecurityPolicy/1.1/module-scriptnonce-redirect-expected.txt
>new file mode 100644
>index 0000000000000000000000000000000000000000..216a27aa912d174d67d59c599d22f64dca885eda
>--- /dev/null
>+++ b/LayoutTests/http/tests/security/contentSecurityPolicy/1.1/module-scriptnonce-redirect-expected.txt
>@@ -0,0 +1,4 @@
>+CONSOLE MESSAGE: Origin http://127.0.0.1:8000 is not allowed by Access-Control-Allow-Origin.
>+CONSOLE MESSAGE: line 1: TypeError: Cross-origin script load denied by Cross-Origin Resource Sharing policy.
>+Script preloaded: NO
>+This tests whether a deferred script load caused by a redirect is properly allowed by a nonce.
>diff --git a/LayoutTests/http/tests/security/contentSecurityPolicy/1.1/module-scriptnonce-redirect-same-origin-expected.txt b/LayoutTests/http/tests/security/contentSecurityPolicy/1.1/module-scriptnonce-redirect-same-origin-expected.txt
>new file mode 100644
>index 0000000000000000000000000000000000000000..a4f72b7c5421b0b53df0f357aadaf9cbfe186c9d
>--- /dev/null
>+++ b/LayoutTests/http/tests/security/contentSecurityPolicy/1.1/module-scriptnonce-redirect-same-origin-expected.txt
>@@ -0,0 +1,3 @@
>+ALERT: PASS
>+Script preloaded: NO
>+This tests whether a deferred script load caused by a redirect is properly allowed by a nonce.
>diff --git a/LayoutTests/http/tests/security/contentSecurityPolicy/1.1/module-scriptnonce-redirect-same-origin.html b/LayoutTests/http/tests/security/contentSecurityPolicy/1.1/module-scriptnonce-redirect-same-origin.html
>new file mode 100644
>index 0000000000000000000000000000000000000000..b918d7545f20d9c6aac3fda3292a8abec66c9247
>--- /dev/null
>+++ b/LayoutTests/http/tests/security/contentSecurityPolicy/1.1/module-scriptnonce-redirect-same-origin.html
>@@ -0,0 +1,27 @@
>+<!DOCTYPE html>
>+<html>
>+    <head>
>+        <meta http-equiv="Content-Security-Policy" content="script-src 'nonce-noncynonce'"></meta>
>+    </head>
>+    <body>
>+        Script preloaded: <span id='preloaded'>UNKNOWN</span><br>
>+        <script nonce="noncynonce">
>+        if (window.testRunner) {
>+            testRunner.dumpAsText();
>+            testRunner.waitUntilDone();
>+        }
>+        </script>
>+        <script type="module" nonce="noncynonce">
>+        if (window.internals) {
>+            var preloaded = internals.isPreloaded("../resources/redir.php?url=http://127.0.0.1:8000/security/contentSecurityPolicy/resources/alert-pass.js");
>+            document.querySelector("#preloaded").innerText = preloaded ? "YES" : "NO";
>+        }
>+        </script>
>+        This tests whether a deferred script load caused by a redirect is properly allowed by a nonce.
>+        <script type="module" nonce='noncynonce' src='../resources/redir.php?url=http://127.0.0.1:8000/security/contentSecurityPolicy/resources/alert-pass.js'></script>
>+        <script type="module" nonce="noncynonce">
>+        if (window.testRunner)
>+            testRunner.notifyDone();
>+        </script>
>+    </body>
>+</html>
>diff --git a/LayoutTests/http/tests/security/contentSecurityPolicy/1.1/module-scriptnonce-redirect.html b/LayoutTests/http/tests/security/contentSecurityPolicy/1.1/module-scriptnonce-redirect.html
>new file mode 100644
>index 0000000000000000000000000000000000000000..c83183ee8a3f4c530217fea33719fbe2a0745c20
>--- /dev/null
>+++ b/LayoutTests/http/tests/security/contentSecurityPolicy/1.1/module-scriptnonce-redirect.html
>@@ -0,0 +1,27 @@
>+<!DOCTYPE html>
>+<html>
>+    <head>
>+        <meta http-equiv="Content-Security-Policy" content="script-src 'nonce-noncynonce'"></meta>
>+    </head>
>+    <body>
>+        Script preloaded: <span id='preloaded'>UNKNOWN</span><br>
>+        <script nonce="noncynonce">
>+        if (window.testRunner) {
>+            testRunner.dumpAsText();
>+            testRunner.waitUntilDone();
>+        }
>+        </script>
>+        <script type="module" nonce="noncynonce">
>+        if (window.internals) {
>+            var preloaded = internals.isPreloaded("../resources/redir.php?url=http://localhost:8000/security/contentSecurityPolicy/resources/alert-pass.js");
>+            document.querySelector("#preloaded").innerText = preloaded ? "YES" : "NO";
>+        }
>+        </script>
>+        This tests whether a deferred script load caused by a redirect is properly allowed by a nonce.
>+        <script type="module" nonce='noncynonce' src='../resources/redir.php?url=http://localhost:8000/security/contentSecurityPolicy/resources/alert-pass.js'></script>
>+        <script type="module" nonce="noncynonce">
>+        if (window.testRunner)
>+            testRunner.notifyDone();
>+        </script>
>+    </body>
>+</html>
>diff --git a/LayoutTests/http/tests/security/contentSecurityPolicy/1.1/resources/module-scriptnonce-in-enforced-policy-and-not-in-report-only.php b/LayoutTests/http/tests/security/contentSecurityPolicy/1.1/resources/module-scriptnonce-in-enforced-policy-and-not-in-report-only.php
>new file mode 100644
>index 0000000000000000000000000000000000000000..1dc66080aeec3a066a03d9f737ec2d4d8a436157
>--- /dev/null
>+++ b/LayoutTests/http/tests/security/contentSecurityPolicy/1.1/resources/module-scriptnonce-in-enforced-policy-and-not-in-report-only.php
>@@ -0,0 +1,19 @@
>+<?
>+    header("Content-Security-Policy: script-src 'nonce-test'");
>+    header("Content-Security-Policy-Report-Only: script-src 'none'");
>+?>
>+<!DOCTYPE html>
>+<html>
>+<body>
>+<p id="script-with-nonce-result">FAIL did not execute script with nonce.</p>
>+<p id="script-without-nonce-result">PASS did not execute script without nonce.</p>
>+<script type="module" nonce="test">
>+document.getElementById("script-with-nonce-result").textContent = "PASS did execute script with nonce.";
>+if (window.testRunner)
>+    testRunner.notifyDone();
>+</script>
>+<script type="module" >
>+document.getElementById("script-without-nonce-result").textContent = "FAIL did execute script without nonce.";
>+</script>
>+</body>
>+</html>
>diff --git a/LayoutTests/http/tests/security/contentSecurityPolicy/1.1/resources/module-scriptnonce-in-one-enforced-policy-neither-in-another-enforced-policy-nor-report-policy.php b/LayoutTests/http/tests/security/contentSecurityPolicy/1.1/resources/module-scriptnonce-in-one-enforced-policy-neither-in-another-enforced-policy-nor-report-policy.php
>new file mode 100644
>index 0000000000000000000000000000000000000000..d937196c16d075f0acd6ac9725b93d323f7187af
>--- /dev/null
>+++ b/LayoutTests/http/tests/security/contentSecurityPolicy/1.1/resources/module-scriptnonce-in-one-enforced-policy-neither-in-another-enforced-policy-nor-report-policy.php
>@@ -0,0 +1,15 @@
>+<?php
>+    header("Content-Security-Policy-Report-Only: object-src 'none'"); // Arbitrary non-{script, img}-src directive
>+    header("Content-Security-Policy: script-src 'nonce-test', img-src 'none'"); // Two policies; second policy has arbitrary non-script-src directive
>+?>
>+<!DOCTYPE html>
>+<html>
>+<body>
>+<p id="result">FAIL did not execute script.</p>
>+<script type="module" nonce="test">
>+document.getElementById("result").textContent = "PASS did execute script.";
>+if (window.testRunner)
>+    testRunner.notifyDone();
>+</script>
>+</body>
>+</html>
>diff --git a/LayoutTests/http/tests/security/contentSecurityPolicy/resources/echo-module-script-src.pl b/LayoutTests/http/tests/security/contentSecurityPolicy/resources/echo-module-script-src.pl
>new file mode 100755
>index 0000000000000000000000000000000000000000..a8bbe16fc23c3955a91963c3e42bfe995f81426d
>--- /dev/null
>+++ b/LayoutTests/http/tests/security/contentSecurityPolicy/resources/echo-module-script-src.pl
>@@ -0,0 +1,32 @@
>+#!/usr/bin/perl -wT
>+use strict;
>+use CGI;
>+
>+my $cgi = new CGI;
>+
>+print "Content-Type: text/html; charset=UTF-8\n";
>+my $experimental = $cgi->param('experimental') || "";
>+if ($experimental eq 'true') {
>+    print "X-WebKit-CSP: " . $cgi->param('csp') . "\n\n";
>+} else {
>+    print "Content-Security-Policy: " . $cgi->param('csp') . "\n\n";
>+}
>+
>+my ($text, $replacement) = ("FAIL", "PASS");
>+($text, $replacement) = ($replacement, $text) if $cgi->param('should_run') eq 'no';
>+
>+my $nonce = $cgi->param('nonce') || "";
>+if ($nonce ne "") {
>+    $nonce = "nonce='" . $nonce . "'";
>+}
>+
>+
>+print "<!DOCTYPE html>\n";
>+print "<html>\n";
>+print "<body>\n";
>+print "<div id=\"result\" text=\"$replacement\">\n";
>+print "$text\n";
>+print "</div>\n";
>+print "<script $nonce type=\"module\" src=\"" . $cgi->param('q') . "\"></script>\n";
>+print "</body>\n";
>+print "</html>\n";
>diff --git a/LayoutTests/http/tests/security/contentSecurityPolicy/resources/multiple-iframe-module-test.js b/LayoutTests/http/tests/security/contentSecurityPolicy/resources/multiple-iframe-module-test.js
>new file mode 100644
>index 0000000000000000000000000000000000000000..d4efebf98d44337dbce62413b464c6dcff0792ba
>--- /dev/null
>+++ b/LayoutTests/http/tests/security/contentSecurityPolicy/resources/multiple-iframe-module-test.js
>@@ -0,0 +1,51 @@
>+if (window.testRunner) {
>+    testRunner.waitUntilDone();
>+    testRunner.dumpAsText();
>+    testRunner.dumpChildFramesAsText();
>+}
>+
>+function testPreescapedPolicy() {
>+    testImpl(false, true);
>+}
>+
>+function testExperimentalPolicy() {
>+    testImpl(true, false);
>+}
>+
>+function test() {
>+    testImpl(false, false);
>+}
>+
>+function testImpl(experimental, preescapedPolicy) {
>+    if (tests.length === 0)
>+        return finishTesting();
>+
>+    var baseURL = "/security/contentSecurityPolicy/";
>+    var current = tests.shift();
>+    var iframe = document.createElement("iframe");
>+
>+    var policy = current[1];
>+    if (!preescapedPolicy)
>+        policy = encodeURIComponent(policy);
>+
>+    var scriptToLoad = baseURL + encodeURIComponent(current[2]);
>+    if (current[2].match(/^data:/) || current[2].match(/^https?:/))
>+        scriptToLoad = encodeURIComponent(current[2]);
>+
>+    iframe.src = baseURL + "resources/echo-module-script-src.pl?" +
>+                 "experimental=" + (experimental ? "true" : "false") +
>+                 "&should_run=" + encodeURIComponent(current[0]) +
>+                 "&csp=" + policy + "&q=" + scriptToLoad;
>+    if (current[3] !== undefined)
>+      iframe.src += "&nonce=" + encodeURIComponent(current[3]);
>+
>+    iframe.onload = function() { testImpl(experimental, preescapedPolicy); };
>+    document.body.appendChild(iframe);
>+}
>+
>+function finishTesting() {
>+    if (window.testRunner) {
>+        setTimeout("testRunner.notifyDone()", 0);
>+    }
>+    return true;
>+}
>diff --git a/LayoutTests/http/tests/security/module-correct-mime-types-expected.txt b/LayoutTests/http/tests/security/module-correct-mime-types-expected.txt
>new file mode 100644
>index 0000000000000000000000000000000000000000..301ccfb65356281ce3020a53783ae94f22bea76b
>--- /dev/null
>+++ b/LayoutTests/http/tests/security/module-correct-mime-types-expected.txt
>@@ -0,0 +1,27 @@
>+CONSOLE MESSAGE: line 1: Executed script with MIME type: 'application/ecmascript'.
>+CONSOLE MESSAGE: line 1: Executed script with MIME type: 'application/javascript'.
>+CONSOLE MESSAGE: line 1: Executed script with MIME type: 'application/x-ecmascript'.
>+CONSOLE MESSAGE: line 1: Executed script with MIME type: 'application/x-javascript'.
>+CONSOLE MESSAGE: line 1: Executed script with MIME type: 'text/ecmascript'.
>+CONSOLE MESSAGE: line 1: Executed script with MIME type: 'text/javascript'.
>+CONSOLE MESSAGE: line 1: Executed script with MIME type: 'text/javascript1.0'.
>+CONSOLE MESSAGE: line 1: Executed script with MIME type: 'text/javascript1.1'.
>+CONSOLE MESSAGE: line 1: Executed script with MIME type: 'text/javascript1.2'.
>+CONSOLE MESSAGE: line 1: Executed script with MIME type: 'text/javascript1.3'.
>+CONSOLE MESSAGE: line 1: Executed script with MIME type: 'text/javascript1.4'.
>+CONSOLE MESSAGE: line 1: Executed script with MIME type: 'text/javascript1.5'.
>+CONSOLE MESSAGE: line 1: Executed script with MIME type: 'text/jscript'.
>+CONSOLE MESSAGE: line 1: Executed script with MIME type: 'text/livescript'.
>+CONSOLE MESSAGE: line 1: Executed script with MIME type: 'text/x-ecmascript'.
>+CONSOLE MESSAGE: line 1: Executed script with MIME type: 'text/x-javascript'.
>+Test module rejects scripts with correct mime types.
>+
>+On success, you will see a series of "PASS" messages, followed by "TEST COMPLETE".
>+
>+
>+Module is not executed yet.
>+Module rejects scripts with correct mime types.
>+PASS successfullyParsed is true
>+
>+TEST COMPLETE
>+
>diff --git a/LayoutTests/http/tests/security/module-correct-mime-types.html b/LayoutTests/http/tests/security/module-correct-mime-types.html
>new file mode 100644
>index 0000000000000000000000000000000000000000..85dd8b6b92c490c1e077272e632c5478d3c71b77
>--- /dev/null
>+++ b/LayoutTests/http/tests/security/module-correct-mime-types.html
>@@ -0,0 +1,58 @@
>+<!DOCTYPE HTML>
>+<html>
>+<head>
>+<script src="../../resources/js-test-pre.js"></script>
>+</head>
>+<body>
>+<script>
>+description('Test module rejects scripts with correct mime types.');
>+
>+// Module will be executed asynchronously.
>+window.jsTestIsAsync = true;
>+</script>
>+<script>
>+let unscriptyMimeTypes = [
>+    'application/ecmascript',
>+    'application/javascript',
>+    'application/x-ecmascript',
>+    'application/x-javascript',
>+    'text/ecmascript',
>+    'text/javascript',
>+    'text/javascript1.0',
>+    'text/javascript1.1',
>+    'text/javascript1.2',
>+    'text/javascript1.3',
>+    'text/javascript1.4',
>+    'text/javascript1.5',
>+    'text/jscript',
>+    'text/livescript',
>+    'text/x-ecmascript',
>+    'text/x-javascript',
>+];
>+
>+debug('Module is not executed yet.');
>+
>+let current = Promise.resolve();
>+for (let mimeType of unscriptyMimeTypes) {
>+    current = current.then(() => {
>+        return new Promise((resolve, reject) => {
>+            let script = document.createElement('script');
>+            script.addEventListener('load', (ev) => resolve(ev), false);
>+            script.type = 'module'
>+            script.src = `./contentTypeOptions/resources/script-with-header.pl?mime=${mimeType}`;
>+            document.body.appendChild(script);
>+        });
>+    });
>+}
>+
>+current.then(done);
>+
>+function done()
>+{
>+    debug('Module rejects scripts with correct mime types.');
>+    finishJSTest();
>+}
>+</script>
>+<script src="../../resources/js-test-post.js"></script>
>+</body>
>+</html>
>diff --git a/LayoutTests/http/tests/security/module-crossorigin-error-event-information-expected.txt b/LayoutTests/http/tests/security/module-crossorigin-error-event-information-expected.txt
>new file mode 100644
>index 0000000000000000000000000000000000000000..07048c06ff60a02e958e715f87138573a67c0049
>--- /dev/null
>+++ b/LayoutTests/http/tests/security/module-crossorigin-error-event-information-expected.txt
>@@ -0,0 +1,15 @@
>+CONSOLE MESSAGE: line 1: SomeError
>+The test passes if error event gets unsanitized information about the module script error.
>+
>+On success, you will see a series of "PASS" messages, followed by "TEST COMPLETE".
>+
>+
>+PASS event.message.match(/SomeError/)[0] is "SomeError"
>+PASS event.filename is "http://localhost:8000/security/resources/cors-script.php?fail=true"
>+PASS event.lineno is 1
>+PASS event.colno is 52
>+PASS event.error.toString() is "SomeError"
>+PASS successfullyParsed is true
>+
>+TEST COMPLETE
>+
>diff --git a/LayoutTests/http/tests/security/module-crossorigin-error-event-information.html b/LayoutTests/http/tests/security/module-crossorigin-error-event-information.html
>new file mode 100644
>index 0000000000000000000000000000000000000000..ec3270bad76881807b1458950316dd4ea41d6e70
>--- /dev/null
>+++ b/LayoutTests/http/tests/security/module-crossorigin-error-event-information.html
>@@ -0,0 +1,22 @@
>+<!DOCTYPE html>
>+<head>
>+</head>
>+<body>
>+<script src="../../js-test-resources/js-test-pre.js"></script>
>+<script>
>+window.jsTestIsAsync = true;
>+description("The test passes if error event gets unsanitized information about the module script error.");
>+
>+window.addEventListener('error', function() {
>+    shouldBeEqualToString("event.message.match(/SomeError/)[0]", "SomeError");
>+    shouldBeEqualToString("event.filename", "http://localhost:8000/security/resources/cors-script.php?fail=true");
>+    shouldBe("event.lineno", "1");
>+    shouldBe("event.colno", "52");
>+    shouldBeEqualToString("event.error.toString()", "SomeError");
>+    finishJSTest();
>+});
>+
>+successfullyParsed = true;
>+</script>
>+<script type="module" crossorigin="anonymous" src="http://localhost:8000/security/resources/cors-script.php?fail=true"></script>
>+<script src="../../js-test-resources/js-test-post.js"></script>
>diff --git a/LayoutTests/http/tests/security/module-crossorigin-loads-correctly-credentials-expected.txt b/LayoutTests/http/tests/security/module-crossorigin-loads-correctly-credentials-expected.txt
>new file mode 100644
>index 0000000000000000000000000000000000000000..52ccef26c4c8626c102d67c44cee93488ded083c
>--- /dev/null
>+++ b/LayoutTests/http/tests/security/module-crossorigin-loads-correctly-credentials-expected.txt
>@@ -0,0 +1,4 @@
>+ALERT: script ran.
>+This test passes if the module script loads correctly.
>+
>+PASS
>diff --git a/LayoutTests/http/tests/security/module-crossorigin-loads-correctly-credentials.html b/LayoutTests/http/tests/security/module-crossorigin-loads-correctly-credentials.html
>new file mode 100644
>index 0000000000000000000000000000000000000000..419b60c39f172c93d44584950d2bbecd567e5a28
>--- /dev/null
>+++ b/LayoutTests/http/tests/security/module-crossorigin-loads-correctly-credentials.html
>@@ -0,0 +1,23 @@
>+<body>
>+<p>This test passes if the module script loads correctly.</p>
>+<pre></pre>
>+<script>
>+if (window.testRunner) {
>+    testRunner.dumpAsText();
>+    testRunner.waitUntilDone();
>+}
>+
>+function done(msg) {
>+    document.querySelector("pre").innerHTML = msg;
>+    if (window.testRunner)
>+        testRunner.notifyDone();
>+}
>+
>+var script = document.createElement("script");
>+script.type = "module";
>+script.crossOrigin = "use-credentials";
>+script.src = "http://localhost:8000/security/resources/cors-script.php?credentials=true";
>+script.onload = function() { done("PASS"); }
>+script.onerror = function() { done("FAIL");}
>+document.body.appendChild(script);
>+</script>
>diff --git a/LayoutTests/http/tests/security/module-crossorigin-loads-omit-expected.txt b/LayoutTests/http/tests/security/module-crossorigin-loads-omit-expected.txt
>new file mode 100644
>index 0000000000000000000000000000000000000000..52ccef26c4c8626c102d67c44cee93488ded083c
>--- /dev/null
>+++ b/LayoutTests/http/tests/security/module-crossorigin-loads-omit-expected.txt
>@@ -0,0 +1,4 @@
>+ALERT: script ran.
>+This test passes if the module script loads correctly.
>+
>+PASS
>diff --git a/LayoutTests/http/tests/security/module-crossorigin-loads-omit.html b/LayoutTests/http/tests/security/module-crossorigin-loads-omit.html
>new file mode 100644
>index 0000000000000000000000000000000000000000..679612fd766fc486f30e3f179f4955ed091b5acd
>--- /dev/null
>+++ b/LayoutTests/http/tests/security/module-crossorigin-loads-omit.html
>@@ -0,0 +1,22 @@
>+<body>
>+<p>This test passes if the module script loads correctly.</p>
>+<pre></pre>
>+<script>
>+if (window.testRunner) {
>+    testRunner.dumpAsText();
>+    testRunner.waitUntilDone();
>+}
>+
>+function done(msg) {
>+    document.querySelector("pre").innerHTML = msg;
>+    if (window.testRunner)
>+        testRunner.notifyDone();
>+}
>+
>+var script = document.createElement("script");
>+script.type = "module";
>+script.src = "http://localhost:8000/security/resources/cors-script.php?credentials=false";
>+script.onload = function() { done("PASS"); }
>+script.onerror = function() { done("FAIL");}
>+document.body.appendChild(script);
>+</script>
>diff --git a/LayoutTests/http/tests/security/module-crossorigin-loads-same-origin-expected.txt b/LayoutTests/http/tests/security/module-crossorigin-loads-same-origin-expected.txt
>new file mode 100644
>index 0000000000000000000000000000000000000000..438cd21a6391bf03d1af54882de3b7bd34bf2843
>--- /dev/null
>+++ b/LayoutTests/http/tests/security/module-crossorigin-loads-same-origin-expected.txt
>@@ -0,0 +1,3 @@
>+Test that a module script element with a crossorigin attribute loads same-origin scripts correctly when there's no access control headers in the response.
>+
>+PASS
>diff --git a/LayoutTests/http/tests/security/module-crossorigin-loads-same-origin.html b/LayoutTests/http/tests/security/module-crossorigin-loads-same-origin.html
>new file mode 100644
>index 0000000000000000000000000000000000000000..c2c2cc196832b3373a192df5ca273332d96b41ea
>--- /dev/null
>+++ b/LayoutTests/http/tests/security/module-crossorigin-loads-same-origin.html
>@@ -0,0 +1,16 @@
>+<p>Test that a module script element with a crossorigin attribute loads same-origin scripts correctly when there's no access control headers in the response.</p>
>+<pre>FAIL</pre>
>+<script>
>+if (window.testRunner) {
>+    testRunner.dumpAsText();
>+    testRunner.waitUntilDone();
>+}
>+
>+function loaded() {
>+    document.querySelector("pre").innerHTML = "PASS";
>+    if (window.testRunner)
>+        testRunner.notifyDone();
>+}
>+</script>
>+
>+<script type="module" crossorigin="anonymous" src="resources/localScript.js" onload="loaded()"></script>
>diff --git a/LayoutTests/http/tests/security/module-crossorigin-onerror-information-expected.txt b/LayoutTests/http/tests/security/module-crossorigin-onerror-information-expected.txt
>new file mode 100644
>index 0000000000000000000000000000000000000000..97a84c4780052490c32618a3c2c84baa8720cba3
>--- /dev/null
>+++ b/LayoutTests/http/tests/security/module-crossorigin-onerror-information-expected.txt
>@@ -0,0 +1,15 @@
>+CONSOLE MESSAGE: line 1: SomeError
>+The test passes if window.onerror gets unsanitized information about the module script error.
>+
>+On success, you will see a series of "PASS" messages, followed by "TEST COMPLETE".
>+
>+
>+PASS msg.match(/SomeError/)[0] is "SomeError"
>+PASS url is "http://localhost:8000/security/resources/cors-script.php?fail=true"
>+PASS line is 1
>+PASS column is 52
>+PASS error.toString() is "SomeError"
>+PASS successfullyParsed is true
>+
>+TEST COMPLETE
>+
>diff --git a/LayoutTests/http/tests/security/module-crossorigin-onerror-information.html b/LayoutTests/http/tests/security/module-crossorigin-onerror-information.html
>new file mode 100644
>index 0000000000000000000000000000000000000000..6f6d5c51bc641f914e6896a33238c5afe38ad047
>--- /dev/null
>+++ b/LayoutTests/http/tests/security/module-crossorigin-onerror-information.html
>@@ -0,0 +1,25 @@
>+<!DOCTYPE html>
>+<head>
>+</head>
>+<body>
>+<script src="../../js-test-resources/js-test-pre.js"></script>
>+<script>
>+window.jsTestIsAsync = true;
>+description("The test passes if window.onerror gets unsanitized information about the module script error.");
>+
>+window.onerror = function(msg, url, line, column, error) {
>+    window.msg = msg;
>+    window.url = url;
>+    window.line = line;
>+    window.column = column;
>+    window.error = error;
>+    shouldBeEqualToString("msg.match(/SomeError/)[0]", "SomeError");
>+    shouldBeEqualToString("url", "http://localhost:8000/security/resources/cors-script.php?fail=true");
>+    shouldBe("line", "1");
>+    shouldBe("column", "52");
>+    shouldBeEqualToString("error.toString()", "SomeError");
>+    finishJSTest();
>+}
>+</script>
>+<script type="module" crossorigin="    anonymous " src="http://localhost:8000/security/resources/cors-script.php?fail=true"></script>
>+<script src="../../js-test-resources/js-test-post.js"></script>
>diff --git a/LayoutTests/http/tests/security/module-incorrect-mime-types-expected.txt b/LayoutTests/http/tests/security/module-incorrect-mime-types-expected.txt
>new file mode 100644
>index 0000000000000000000000000000000000000000..4152301b9abd06ae7cd305b99253c8f0d0b1eff4
>--- /dev/null
>+++ b/LayoutTests/http/tests/security/module-incorrect-mime-types-expected.txt
>@@ -0,0 +1,20 @@
>+CONSOLE MESSAGE: TypeError: Refused to execute module script from 'http://127.0.0.1:8000/security/contentTypeOptions/resources/script-with-header.pl?mime=application/json' because its MIME type ('application/json') is not executable.
>+CONSOLE MESSAGE: TypeError: Refused to execute module script from 'http://127.0.0.1:8000/security/contentTypeOptions/resources/script-with-header.pl?mime=application/octet-stream' because its MIME type ('application/octet-stream') is not executable.
>+CONSOLE MESSAGE: TypeError: Refused to execute module script from 'http://127.0.0.1:8000/security/contentTypeOptions/resources/script-with-header.pl?mime=application/xml' because its MIME type ('application/xml') is not executable.
>+CONSOLE MESSAGE: TypeError: Refused to execute module script from 'http://127.0.0.1:8000/security/contentTypeOptions/resources/script-with-header.pl?mime=image/png' because its MIME type ('image/png') is not executable.
>+CONSOLE MESSAGE: TypeError: Refused to execute module script from 'http://127.0.0.1:8000/security/contentTypeOptions/resources/script-with-header.pl?mime=text/html' because its MIME type ('text/html') is not executable.
>+CONSOLE MESSAGE: TypeError: Refused to execute module script from 'http://127.0.0.1:8000/security/contentTypeOptions/resources/script-with-header.pl?mime=text/plain' because its MIME type ('text/plain') is not executable.
>+CONSOLE MESSAGE: TypeError: Refused to execute module script from 'http://127.0.0.1:8000/security/contentTypeOptions/resources/script-with-header.pl?mime=text/vbs' because its MIME type ('text/vbs') is not executable.
>+CONSOLE MESSAGE: TypeError: Refused to execute module script from 'http://127.0.0.1:8000/security/contentTypeOptions/resources/script-with-header.pl?mime=text/vbscript' because its MIME type ('text/vbscript') is not executable.
>+CONSOLE MESSAGE: TypeError: Refused to execute module script from 'http://127.0.0.1:8000/security/contentTypeOptions/resources/script-with-header.pl?mime=text/xml' because its MIME type ('text/xml') is not executable.
>+Test module rejects scripts with incorrect mime types.
>+
>+On success, you will see a series of "PASS" messages, followed by "TEST COMPLETE".
>+
>+
>+Module is not executed yet.
>+Module rejects scripts with incorrect mime types.
>+PASS successfullyParsed is true
>+
>+TEST COMPLETE
>+
>diff --git a/LayoutTests/http/tests/security/module-incorrect-mime-types.html b/LayoutTests/http/tests/security/module-incorrect-mime-types.html
>new file mode 100644
>index 0000000000000000000000000000000000000000..237c37a27dc36d3e50fd4703afe2e49bde2fcaa7
>--- /dev/null
>+++ b/LayoutTests/http/tests/security/module-incorrect-mime-types.html
>@@ -0,0 +1,51 @@
>+<!DOCTYPE HTML>
>+<html>
>+<head>
>+<script src="../../resources/js-test-pre.js"></script>
>+</head>
>+<body>
>+<script>
>+description('Test module rejects scripts with incorrect mime types.');
>+
>+// Module will be executed asynchronously.
>+window.jsTestIsAsync = true;
>+</script>
>+<script>
>+let unscriptyMimeTypes = [
>+    'application/json',
>+    'application/octet-stream',
>+    'application/xml',
>+    'image/png',
>+    'text/html',
>+    'text/plain',
>+    'text/vbs',
>+    'text/vbscript',
>+    'text/xml',
>+];
>+
>+debug('Module is not executed yet.');
>+
>+let current = Promise.resolve();
>+for (let mimeType of unscriptyMimeTypes) {
>+    current = current.then(() => {
>+        return new Promise((resolve, reject) => {
>+            let script = document.createElement('script');
>+            script.addEventListener('error', (ev) => resolve(ev), false);
>+            script.type = 'module'
>+            script.src = `./contentTypeOptions/resources/script-with-header.pl?mime=${mimeType}`;
>+            document.body.appendChild(script);
>+        });
>+    });
>+}
>+
>+current.then(done);
>+
>+function done()
>+{
>+    debug('Module rejects scripts with incorrect mime types.');
>+    finishJSTest();
>+}
>+</script>
>+<script src="../../resources/js-test-post.js"></script>
>+</body>
>+</html>
>diff --git a/LayoutTests/http/tests/security/module-no-mime-type-expected.txt b/LayoutTests/http/tests/security/module-no-mime-type-expected.txt
>new file mode 100644
>index 0000000000000000000000000000000000000000..30c853ccead92ba03d372b9e18ffa4ecb44b84fb
>--- /dev/null
>+++ b/LayoutTests/http/tests/security/module-no-mime-type-expected.txt
>@@ -0,0 +1,12 @@
>+CONSOLE MESSAGE: line 1: TypeError: Refused to execute module script from 'http://127.0.0.1:8000/security/contentTypeOptions/resources/script-with-header.pl' because its MIME type ('application/octet-stream') is not executable.
>+Test module rejects scripts with no mime type.
>+
>+On success, you will see a series of "PASS" messages, followed by "TEST COMPLETE".
>+
>+
>+Module is not executed yet.
>+Module rejects a script with no mime type.
>+PASS successfullyParsed is true
>+
>+TEST COMPLETE
>+
>diff --git a/LayoutTests/http/tests/security/module-no-mime-type.html b/LayoutTests/http/tests/security/module-no-mime-type.html
>new file mode 100644
>index 0000000000000000000000000000000000000000..b0f454b1e21a682d99e34990fbf12133236e854e
>--- /dev/null
>+++ b/LayoutTests/http/tests/security/module-no-mime-type.html
>@@ -0,0 +1,24 @@
>+<!DOCTYPE HTML>
>+<html>
>+<head>
>+<script src="../../resources/js-test-pre.js"></script>
>+</head>
>+<body>
>+<script>
>+description('Test module rejects scripts with no mime type.');
>+
>+// Module will be executed asynchronously.
>+window.jsTestIsAsync = true;
>+</script>
>+<script>
>+debug('Module is not executed yet.');
>+function done()
>+{
>+    debug('Module rejects a script with no mime type.');
>+    finishJSTest();
>+}
>+</script>
>+<script src="../../resources/js-test-post.js"></script>
>+<script type="module" src="./contentTypeOptions/resources/script-with-header.pl" onerror="done()"></script>
>+</body>
>+</html>
>diff --git a/LayoutTests/http/tests/security/module-requires-javascript-mime-types-expected.txt b/LayoutTests/http/tests/security/module-requires-javascript-mime-types-expected.txt
>new file mode 100644
>index 0000000000000000000000000000000000000000..997023dead36bdf21d8a5d3d156ac96da91320ac
>--- /dev/null
>+++ b/LayoutTests/http/tests/security/module-requires-javascript-mime-types-expected.txt
>@@ -0,0 +1,12 @@
>+CONSOLE MESSAGE: line 1: TypeError: Refused to execute module script from 'http://127.0.0.1:8000/security/contentTypeOptions/resources/script-with-header.pl' because its MIME type ('application/octet-stream') is not executable.
>+Test module rejects scripts with no mime type.
>+
>+On success, you will see a series of "PASS" messages, followed by "TEST COMPLETE".
>+
>+
>+Module is not executed yet.
>+Module rejects a script with no mime type
>+PASS successfullyParsed is true
>+
>+TEST COMPLETE
>+
>diff --git a/LayoutTests/http/tests/security/module-requires-javascript-mime-types.html b/LayoutTests/http/tests/security/module-requires-javascript-mime-types.html
>new file mode 100644
>index 0000000000000000000000000000000000000000..1525e95cc4203048aa8a7422b7e8f96c7b4e4e35
>--- /dev/null
>+++ b/LayoutTests/http/tests/security/module-requires-javascript-mime-types.html
>@@ -0,0 +1,24 @@
>+<!DOCTYPE HTML>
>+<html>
>+<head>
>+<script src="../../resources/js-test-pre.js"></script>
>+</head>
>+<body>
>+<script>
>+description('Test module rejects scripts with no mime type.');
>+
>+// Module will be executed asynchronously.
>+window.jsTestIsAsync = true;
>+</script>
>+<script>
>+debug('Module is not executed yet.');
>+function done()
>+{
>+    debug('Module rejects a script with no mime type');
>+    finishJSTest();
>+}
>+</script>
>+<script src="../../resources/js-test-post.js"></script>
>+<script type="module" src="./contentTypeOptions/resources/script-with-header.pl" onerror="done()"></script>
>+</body>
>+</html>
>diff --git a/LayoutTests/http/tests/security/resources/cors-script.php b/LayoutTests/http/tests/security/resources/cors-script.php
>index a71df84d2ccfbfb74a912c2269654ee72d92b568..d0b32978e843902fddd21ef11be709d80fe47d54 100644
>--- a/LayoutTests/http/tests/security/resources/cors-script.php
>+++ b/LayoutTests/http/tests/security/resources/cors-script.php
>@@ -2,8 +2,12 @@
> header("Access-Control-Allow-Origin: http://127.0.0.1:8000");
> header("Content-Type: application/javascript");
> 
>-if (strtolower($_GET["credentials"]) == "true") {
>-    header("Access-Control-Allow-Credentials: true");
>+if (isset($_GET["credentials"])) {
>+    if (strtolower($_GET["credentials"]) == "true") {
>+        header("Access-Control-Allow-Credentials: true");
>+    } else {
>+        header("Access-Control-Allow-Credentials: false");
>+    }
> }
> 
> if (strtolower($_GET["fail"]) == "true")
>diff --git a/LayoutTests/js/dom/module-and-dom-content-loaded-expected.txt b/LayoutTests/js/dom/module-and-dom-content-loaded-expected.txt
>new file mode 100644
>index 0000000000000000000000000000000000000000..0d9105f9cae4ea67c13b8a4f267f0ed46770eab6
>--- /dev/null
>+++ b/LayoutTests/js/dom/module-and-dom-content-loaded-expected.txt
>@@ -0,0 +1,10 @@
>+Test window DOMContentLoaded event is fired after module is executed.
>+
>+On success, you will see a series of "PASS" messages, followed by "TEST COMPLETE".
>+
>+
>+Module is not executed yet.
>+PASS successfullyParsed is true
>+
>+TEST COMPLETE
>+
>diff --git a/LayoutTests/js/dom/module-and-dom-content-loaded.html b/LayoutTests/js/dom/module-and-dom-content-loaded.html
>new file mode 100644
>index 0000000000000000000000000000000000000000..2689d370f4cf7f81e861bddb9d9c55a7e22930e1
>--- /dev/null
>+++ b/LayoutTests/js/dom/module-and-dom-content-loaded.html
>@@ -0,0 +1,24 @@
>+<!DOCTYPE HTML>
>+<html>
>+<head>
>+<script src="../../resources/js-test-pre.js"></script>
>+</head>
>+<body>
>+<script>
>+description('Test window DOMContentLoaded event is fired after module is executed.');
>+
>+// Module will be executed asynchronously.
>+window.jsTestIsAsync = true;
>+</script>
>+<script>
>+debug('Module is not executed yet.');
>+</script>
>+<script src="../../resources/js-test-post.js"></script>
>+<script type="module">
>+window.addEventListener('DOMContentLoaded', function ()
>+{
>+    finishJSTest();
>+}, false);
>+</script>
>+</body>
>+</html>
>diff --git a/LayoutTests/js/dom/module-and-window-load-expected.txt b/LayoutTests/js/dom/module-and-window-load-expected.txt
>new file mode 100644
>index 0000000000000000000000000000000000000000..5bc06d3f26477a3430e80b8b889c08021335d85f
>--- /dev/null
>+++ b/LayoutTests/js/dom/module-and-window-load-expected.txt
>@@ -0,0 +1,10 @@
>+Test window.load is fired after module is executed.
>+
>+On success, you will see a series of "PASS" messages, followed by "TEST COMPLETE".
>+
>+
>+Module is not executed yet.
>+PASS successfullyParsed is true
>+
>+TEST COMPLETE
>+
>diff --git a/LayoutTests/js/dom/module-and-window-load.html b/LayoutTests/js/dom/module-and-window-load.html
>new file mode 100644
>index 0000000000000000000000000000000000000000..506772224af0d036268c8d9df5c70ab6f7aa3580
>--- /dev/null
>+++ b/LayoutTests/js/dom/module-and-window-load.html
>@@ -0,0 +1,24 @@
>+<!DOCTYPE HTML>
>+<html>
>+<head>
>+<script src="../../resources/js-test-pre.js"></script>
>+</head>
>+<body>
>+<script>
>+description('Test window.load is fired after module is executed.');
>+
>+// Module will be executed asynchronously.
>+window.jsTestIsAsync = true;
>+</script>
>+<script>
>+debug('Module is not executed yet.');
>+</script>
>+<script src="../../resources/js-test-post.js"></script>
>+<script type="module">
>+window.onload = function ()
>+{
>+    finishJSTest();
>+}
>+</script>
>+</body>
>+</html>
>diff --git a/LayoutTests/js/dom/module-async-and-window-load-expected.txt b/LayoutTests/js/dom/module-async-and-window-load-expected.txt
>new file mode 100644
>index 0000000000000000000000000000000000000000..5bc06d3f26477a3430e80b8b889c08021335d85f
>--- /dev/null
>+++ b/LayoutTests/js/dom/module-async-and-window-load-expected.txt
>@@ -0,0 +1,10 @@
>+Test window.load is fired after module is executed.
>+
>+On success, you will see a series of "PASS" messages, followed by "TEST COMPLETE".
>+
>+
>+Module is not executed yet.
>+PASS successfullyParsed is true
>+
>+TEST COMPLETE
>+
>diff --git a/LayoutTests/js/dom/module-async-and-window-load.html b/LayoutTests/js/dom/module-async-and-window-load.html
>new file mode 100644
>index 0000000000000000000000000000000000000000..a771d2c965690bddbf5dd74547a97542238118b8
>--- /dev/null
>+++ b/LayoutTests/js/dom/module-async-and-window-load.html
>@@ -0,0 +1,24 @@
>+<!DOCTYPE HTML>
>+<html>
>+<head>
>+<script src="../../resources/js-test-pre.js"></script>
>+</head>
>+<body>
>+<script>
>+description('Test window.load is fired after module is executed.');
>+
>+// Module will be executed asynchronously.
>+window.jsTestIsAsync = true;
>+</script>
>+<script>
>+debug('Module is not executed yet.');
>+</script>
>+<script src="../../resources/js-test-post.js"></script>
>+<script type="module" async>
>+window.onload = function ()
>+{
>+    finishJSTest();
>+}
>+</script>
>+</body>
>+</html>
>diff --git a/LayoutTests/js/dom/module-document-write-expected.txt b/LayoutTests/js/dom/module-document-write-expected.txt
>new file mode 100644
>index 0000000000000000000000000000000000000000..3f11cf6b7c1641238ef822b4c57b4c7629136a16
>--- /dev/null
>+++ b/LayoutTests/js/dom/module-document-write-expected.txt
>@@ -0,0 +1,10 @@
>+Test that document.write does not work inside module.
>+
>+On success, you will see a series of "PASS" messages, followed by "TEST COMPLETE".
>+
>+
>+Module is not executed yet.
>+PASS successfullyParsed is true
>+
>+TEST COMPLETE
>+
>diff --git a/LayoutTests/js/dom/module-document-write-src-expected.txt b/LayoutTests/js/dom/module-document-write-src-expected.txt
>new file mode 100644
>index 0000000000000000000000000000000000000000..3f11cf6b7c1641238ef822b4c57b4c7629136a16
>--- /dev/null
>+++ b/LayoutTests/js/dom/module-document-write-src-expected.txt
>@@ -0,0 +1,10 @@
>+Test that document.write does not work inside module.
>+
>+On success, you will see a series of "PASS" messages, followed by "TEST COMPLETE".
>+
>+
>+Module is not executed yet.
>+PASS successfullyParsed is true
>+
>+TEST COMPLETE
>+
>diff --git a/LayoutTests/js/dom/module-document-write-src.html b/LayoutTests/js/dom/module-document-write-src.html
>new file mode 100644
>index 0000000000000000000000000000000000000000..2e169e6974ce40c292394adf8b9812e931b7aa01
>--- /dev/null
>+++ b/LayoutTests/js/dom/module-document-write-src.html
>@@ -0,0 +1,19 @@
>+<!DOCTYPE HTML>
>+<html>
>+<head>
>+<script src="../../resources/js-test-pre.js"></script>
>+</head>
>+<body>
>+<script>
>+description('Test that document.write does not work inside module.');
>+
>+// Module will be executed asynchronously.
>+window.jsTestIsAsync = true;
>+</script>
>+<script>
>+debug('Module is not executed yet.');
>+</script>
>+<script src="../../resources/js-test-post.js"></script>
>+<script type="module" src="script-tests/module-document-write-src.js"></script>
>+</body>
>+</html>
>diff --git a/LayoutTests/js/dom/module-document-write.html b/LayoutTests/js/dom/module-document-write.html
>new file mode 100644
>index 0000000000000000000000000000000000000000..ea559eab4c9798482868d645349c5b14971f212d
>--- /dev/null
>+++ b/LayoutTests/js/dom/module-document-write.html
>@@ -0,0 +1,22 @@
>+<!DOCTYPE HTML>
>+<html>
>+<head>
>+<script src="../../resources/js-test-pre.js"></script>
>+</head>
>+<body>
>+<script>
>+description('Test that document.write does not work inside module.');
>+
>+// Module will be executed asynchronously.
>+window.jsTestIsAsync = true;
>+</script>
>+<script>
>+debug('Module is not executed yet.');
>+</script>
>+<script src="../../resources/js-test-post.js"></script>
>+<script type="module">
>+document.write("TEST FAILED");
>+finishJSTest();
>+</script>
>+</body>
>+</html>
>diff --git a/LayoutTests/js/dom/module-execution-error-inside-dependent-module-should-be-propagated-to-onerror-expected.txt b/LayoutTests/js/dom/module-execution-error-inside-dependent-module-should-be-propagated-to-onerror-expected.txt
>new file mode 100644
>index 0000000000000000000000000000000000000000..9bdb275a2fb8348964fbe8deb82553b4b9db9a52
>--- /dev/null
>+++ b/LayoutTests/js/dom/module-execution-error-inside-dependent-module-should-be-propagated-to-onerror-expected.txt
>@@ -0,0 +1,11 @@
>+Test window.onerror will be fired when the dependent module throw an error.
>+
>+On success, you will see a series of "PASS" messages, followed by "TEST COMPLETE".
>+
>+
>+Module is not executed yet.
>+Executing the dependent module
>+PASS successfullyParsed is true
>+
>+TEST COMPLETE
>+
>diff --git a/LayoutTests/js/dom/module-execution-error-inside-dependent-module-should-be-propagated-to-onerror.html b/LayoutTests/js/dom/module-execution-error-inside-dependent-module-should-be-propagated-to-onerror.html
>new file mode 100644
>index 0000000000000000000000000000000000000000..d0907f783c08d9acb7f2fe86e4773410b7606772
>--- /dev/null
>+++ b/LayoutTests/js/dom/module-execution-error-inside-dependent-module-should-be-propagated-to-onerror.html
>@@ -0,0 +1,22 @@
>+<!DOCTYPE HTML>
>+<html>
>+<head>
>+<script src="../../resources/js-test-pre.js"></script>
>+</head>
>+<body>
>+<script>
>+description('Test window.onerror will be fired when the dependent module throw an error.');
>+// Module will be executed asynchronously.
>+window.jsTestIsAsync = true;
>+debug('Module is not executed yet.');
>+window.onerror = function () {
>+    finishJSTest();
>+}
>+</script>
>+<script src="../../resources/js-test-post.js"></script>
>+<script type="module">
>+import "./script-tests/module-execution-error-inside-dependent-module-should-be-propagated-to-onerror.js"
>+testFailed("executed");
>+</script>
>+</body>
>+</html>
>diff --git a/LayoutTests/js/dom/module-execution-error-should-be-propagated-to-onerror-expected.txt b/LayoutTests/js/dom/module-execution-error-should-be-propagated-to-onerror-expected.txt
>new file mode 100644
>index 0000000000000000000000000000000000000000..a5df7028f354936692922efe61a2dfba5f1f0935
>--- /dev/null
>+++ b/LayoutTests/js/dom/module-execution-error-should-be-propagated-to-onerror-expected.txt
>@@ -0,0 +1,11 @@
>+Test window.onerror will be fired when the inlined module throws an error.
>+
>+On success, you will see a series of "PASS" messages, followed by "TEST COMPLETE".
>+
>+
>+Module is not executed yet.
>+Executing the module.
>+PASS successfullyParsed is true
>+
>+TEST COMPLETE
>+
>diff --git a/LayoutTests/js/dom/module-execution-error-should-be-propagated-to-onerror.html b/LayoutTests/js/dom/module-execution-error-should-be-propagated-to-onerror.html
>new file mode 100644
>index 0000000000000000000000000000000000000000..4aec303f8f9d38273353eb8979167d39dc591c9a
>--- /dev/null
>+++ b/LayoutTests/js/dom/module-execution-error-should-be-propagated-to-onerror.html
>@@ -0,0 +1,22 @@
>+<!DOCTYPE HTML>
>+<html>
>+<head>
>+<script src="../../resources/js-test-pre.js"></script>
>+</head>
>+<body>
>+<script>
>+description('Test window.onerror will be fired when the inlined module throws an error.');
>+// Module will be executed asynchronously.
>+window.jsTestIsAsync = true;
>+debug('Module is not executed yet.');
>+window.onerror = function () {
>+    finishJSTest();
>+}
>+</script>
>+<script src="../../resources/js-test-post.js"></script>
>+<script type="module">
>+debug('Executing the module.');
>+throw new Error("module is executed.");
>+</script>
>+</body>
>+</html>
>diff --git a/LayoutTests/js/dom/module-execution-order-inline-expected.txt b/LayoutTests/js/dom/module-execution-order-inline-expected.txt
>new file mode 100644
>index 0000000000000000000000000000000000000000..fffdf339757a4a37964e889aec69afcc599ab78f
>--- /dev/null
>+++ b/LayoutTests/js/dom/module-execution-order-inline-expected.txt
>@@ -0,0 +1,14 @@
>+Test module execution order between inlined module tags.
>+
>+On success, you will see a series of "PASS" messages, followed by "TEST COMPLETE".
>+
>+
>+Module is not executed yet.
>+PASS count++ is 0
>+PASS count++ is 1
>+PASS count++ is 2
>+PASS count++ is 3
>+PASS successfullyParsed is true
>+
>+TEST COMPLETE
>+
>diff --git a/LayoutTests/js/dom/module-execution-order-inline.html b/LayoutTests/js/dom/module-execution-order-inline.html
>new file mode 100644
>index 0000000000000000000000000000000000000000..5855c16d0a8151c60d36e6010c316703116d6e5c
>--- /dev/null
>+++ b/LayoutTests/js/dom/module-execution-order-inline.html
>@@ -0,0 +1,27 @@
>+<!DOCTYPE HTML>
>+<html>
>+<head>
>+<script src="../../resources/js-test-pre.js"></script>
>+</head>
>+<body>
>+<script>
>+description('Test module execution order between inlined module tags.');
>+window.count = 0;
>+// Module will be executed asynchronously.
>+window.jsTestIsAsync = true;
>+debug('Module is not executed yet.');
>+shouldBe("count++", "0");
>+</script>
>+<script src="../../resources/js-test-post.js"></script>
>+<script type="module">
>+shouldBe("count++", "1");
>+</script>
>+<script type="module">
>+shouldBe("count++", "2");
>+</script>
>+<script type="module">
>+shouldBe("count++", "3");
>+finishJSTest();
>+</script>
>+</body>
>+</html>
>diff --git a/LayoutTests/js/dom/module-execution-order-mixed-expected.txt b/LayoutTests/js/dom/module-execution-order-mixed-expected.txt
>new file mode 100644
>index 0000000000000000000000000000000000000000..f37f524f531905d8a53f44a33ab6ffb400121030
>--- /dev/null
>+++ b/LayoutTests/js/dom/module-execution-order-mixed-expected.txt
>@@ -0,0 +1,18 @@
>+Test module execution order between mixed tags.
>+
>+On success, you will see a series of "PASS" messages, followed by "TEST COMPLETE".
>+
>+
>+We keep the execution order between modules.
>+Module is not executed yet.
>+PASS count++ is 0
>+PASS count++ is 1
>+PASS count++ is 2
>+PASS count++ is 3
>+PASS count++ is 4
>+PASS count++ is 5
>+PASS count++ is 6
>+PASS successfullyParsed is true
>+
>+TEST COMPLETE
>+
>diff --git a/LayoutTests/js/dom/module-execution-order-mixed.html b/LayoutTests/js/dom/module-execution-order-mixed.html
>new file mode 100644
>index 0000000000000000000000000000000000000000..d894c52a7518776e437bd74d8ccddb65c57d68df
>--- /dev/null
>+++ b/LayoutTests/js/dom/module-execution-order-mixed.html
>@@ -0,0 +1,27 @@
>+<!DOCTYPE HTML>
>+<html>
>+<head>
>+<script src="../../resources/js-test-pre.js"></script>
>+</head>
>+<body>
>+<script>
>+description('Test module execution order between mixed tags.');
>+debug('We keep the execution order between modules.');
>+window.count = 0;
>+
>+// Module will be executed asynchronously.
>+window.jsTestIsAsync = true;
>+debug('Module is not executed yet.');
>+</script>
>+<script src="../../resources/js-test-post.js"></script>
>+<script type="module" src="script-tests/module-execution-order-mixed.js"></script>
>+<script type="module">
>+shouldBe("count++", "4");
>+</script>
>+<script type="module" src="script-tests/module-execution-order-mixed-2.js"></script>
>+<script type="module">
>+shouldBe("count++", "6");
>+finishJSTest();
>+</script>
>+</body>
>+</html>
>diff --git a/LayoutTests/js/dom/module-incorrect-relative-specifier-expected.txt b/LayoutTests/js/dom/module-incorrect-relative-specifier-expected.txt
>new file mode 100644
>index 0000000000000000000000000000000000000000..aaf06468af7a5572963f8b66bfe2061a1835dcd0
>--- /dev/null
>+++ b/LayoutTests/js/dom/module-incorrect-relative-specifier-expected.txt
>@@ -0,0 +1,16 @@
>+CONSOLE MESSAGE: line 1: TypeError: Module specifier does not start with "/", "./", or "../".
>+CONSOLE MESSAGE: line 1: TypeError: Module specifier does not start with "/", "./", or "../".
>+CONSOLE MESSAGE: line 1: TypeError: Module specifier does not start with "/", "./", or "../".
>+Test script.onerror will be fired when the incorrect relative specifier is specified.
>+
>+On success, you will see a series of "PASS" messages, followed by "TEST COMPLETE".
>+
>+
>+Module is not executed yet.
>+0
>+1
>+2
>+PASS successfullyParsed is true
>+
>+TEST COMPLETE
>+
>diff --git a/LayoutTests/js/dom/module-incorrect-relative-specifier.html b/LayoutTests/js/dom/module-incorrect-relative-specifier.html
>new file mode 100644
>index 0000000000000000000000000000000000000000..44c161e75f6aaf7eb8395fac65e33d777432cde9
>--- /dev/null
>+++ b/LayoutTests/js/dom/module-incorrect-relative-specifier.html
>@@ -0,0 +1,35 @@
>+<!DOCTYPE HTML>
>+<html>
>+<head>
>+<script src="../../resources/js-test-pre.js"></script>
>+</head>
>+<body>
>+<script>
>+description('Test script.onerror will be fired when the incorrect relative specifier is specified.');
>+// Module will be executed asynchronously.
>+window.jsTestIsAsync = true;
>+debug('Module is not executed yet.');
>+var count = 0;
>+function errorHandler() {
>+    var current = count++;
>+    debug(`${current}`);
>+    if (count === 3)
>+        finishJSTest();
>+}
>+</script>
>+<script src="../../resources/js-test-post.js"></script>
>+
>+<script type="module" onerror="errorHandler()">
>+import Incorrect from "incorrect"
>+</script>
>+
>+<script type="module" onerror="errorHandler()">
>+import Incorrect from "$hello"
>+</script>
>+
>+<script type="module" onerror="errorHandler()">
>+import Incorrect from ".../test"
>+</script>
>+
>+</body>
>+</html>
>diff --git a/LayoutTests/js/dom/module-incorrect-tag-expected.txt b/LayoutTests/js/dom/module-incorrect-tag-expected.txt
>new file mode 100644
>index 0000000000000000000000000000000000000000..c1ade360f4f2acd54021de2ce0932e97acda143a
>--- /dev/null
>+++ b/LayoutTests/js/dom/module-incorrect-tag-expected.txt
>@@ -0,0 +1,10 @@
>+Test incorrect module tags.
>+
>+On success, you will see a series of "PASS" messages, followed by "TEST COMPLETE".
>+
>+
>+Module is not executed yet.
>+PASS successfullyParsed is true
>+
>+TEST COMPLETE
>+
>diff --git a/LayoutTests/js/dom/module-incorrect-tag.html b/LayoutTests/js/dom/module-incorrect-tag.html
>new file mode 100644
>index 0000000000000000000000000000000000000000..a3ede5571ea054f24de589688679a1c2a3af5897
>--- /dev/null
>+++ b/LayoutTests/js/dom/module-incorrect-tag.html
>@@ -0,0 +1,33 @@
>+<!DOCTYPE HTML>
>+<html>
>+<head>
>+<script src="../../resources/js-test-pre.js"></script>
>+</head>
>+<body>
>+<script>
>+description('Test incorrect module tags.');
>+
>+// Module will be executed asynchronously.
>+window.jsTestIsAsync = true;
>+</script>
>+<script>
>+debug('Module is not executed yet.');
>+</script>
>+<script src="../../resources/js-test-post.js"></script>
>+<script type="module ">
>+testFail("This is not a module");
>+</script>
>+<script type=" module ">
>+testFail("This is not a module");
>+</script>
>+<script type=" module">
>+testFail("This is not a module");
>+</script>
>+<script type=" moduleXXX">
>+testFail("This is not a module");
>+</script>
>+<script type="module">
>+finishJSTest();
>+</script>
>+</body>
>+</html>
>diff --git a/LayoutTests/js/dom/module-inline-current-script-expected.txt b/LayoutTests/js/dom/module-inline-current-script-expected.txt
>new file mode 100644
>index 0000000000000000000000000000000000000000..7cfe446f4dc0bd87967f9b9b425731d7b5c5149d
>--- /dev/null
>+++ b/LayoutTests/js/dom/module-inline-current-script-expected.txt
>@@ -0,0 +1,12 @@
>+Test document.currentScript should be null when executing the inlined module.
>+
>+On success, you will see a series of "PASS" messages, followed by "TEST COMPLETE".
>+
>+
>+Module is not executed yet.
>+Module execution is confined in the module environment.
>+PASS document.currentScript is null
>+PASS successfullyParsed is true
>+
>+TEST COMPLETE
>+
>diff --git a/LayoutTests/js/dom/module-inline-current-script.html b/LayoutTests/js/dom/module-inline-current-script.html
>new file mode 100644
>index 0000000000000000000000000000000000000000..a5f23171db88885e2ed94ddd0fd063305235e3b8
>--- /dev/null
>+++ b/LayoutTests/js/dom/module-inline-current-script.html
>@@ -0,0 +1,25 @@
>+<!DOCTYPE HTML>
>+<html>
>+<head>
>+<script src="../../resources/js-test-pre.js"></script>
>+</head>
>+<body>
>+<script>
>+description('Test document.currentScript should be null when executing the inlined module.');
>+
>+// Module will be executed asynchronously.
>+window.jsTestIsAsync = true;
>+</script>
>+<script>
>+debug('Module is not executed yet.');
>+</script>
>+<script src="../../resources/js-test-post.js"></script>
>+<script type="module">
>+
>+debug("Module execution is confined in the module environment.");
>+shouldBe("document.currentScript", "null");
>+
>+finishJSTest();
>+</script>
>+</body>
>+</html>
>diff --git a/LayoutTests/js/dom/module-inline-dynamic-expected.txt b/LayoutTests/js/dom/module-inline-dynamic-expected.txt
>new file mode 100644
>index 0000000000000000000000000000000000000000..6c939aaf0a5015f479386cd3195aa59dd1690975
>--- /dev/null
>+++ b/LayoutTests/js/dom/module-inline-dynamic-expected.txt
>@@ -0,0 +1,14 @@
>+Test inlined module.
>+
>+On success, you will see a series of "PASS" messages, followed by "TEST COMPLETE".
>+
>+
>+Module is not executed yet.
>+Module execution is confined in the module environment.
>+PASS typeof cocoa is "undefined"
>+PASS typeof exportedCocoa is "object"
>+PASS exportedCocoa.taste() is "awesome"
>+PASS successfullyParsed is true
>+
>+TEST COMPLETE
>+
>diff --git a/LayoutTests/js/dom/module-inline-dynamic.html b/LayoutTests/js/dom/module-inline-dynamic.html
>new file mode 100644
>index 0000000000000000000000000000000000000000..fd836d8edf7e2820e32253db53da55e0f8851e7e
>--- /dev/null
>+++ b/LayoutTests/js/dom/module-inline-dynamic.html
>@@ -0,0 +1,35 @@
>+<!DOCTYPE HTML>
>+<html>
>+<head>
>+<script src="../../resources/js-test-pre.js"></script>
>+</head>
>+<body>
>+<script>
>+description('Test inlined module.');
>+
>+// Module will be executed asynchronously.
>+window.jsTestIsAsync = true;
>+</script>
>+<script src="../../resources/js-test-post.js"></script>
>+<script>
>+debug('Module is not executed yet.');
>+(function () {
>+    var element = document.createElement("script");
>+    element.textContent = `
>+        import Cocoa from "./script-tests/module-inline-dynamic.js";
>+        var cocoa = new Cocoa();
>+
>+        debug("Module execution is confined in the module environment.");
>+        shouldBeEqualToString("typeof cocoa", "undefined");
>+
>+        window.exportedCocoa = cocoa;
>+        shouldBeEqualToString("typeof exportedCocoa", "object");
>+        shouldBeEqualToString("exportedCocoa.taste()", "awesome");
>+        finishJSTest();
>+    `;
>+    element.type = "module";
>+    document.body.appendChild(element);
>+} ());
>+</script>
>+</body>
>+</html>
>diff --git a/LayoutTests/js/dom/module-inline-simple-expected.txt b/LayoutTests/js/dom/module-inline-simple-expected.txt
>new file mode 100644
>index 0000000000000000000000000000000000000000..6c939aaf0a5015f479386cd3195aa59dd1690975
>--- /dev/null
>+++ b/LayoutTests/js/dom/module-inline-simple-expected.txt
>@@ -0,0 +1,14 @@
>+Test inlined module.
>+
>+On success, you will see a series of "PASS" messages, followed by "TEST COMPLETE".
>+
>+
>+Module is not executed yet.
>+Module execution is confined in the module environment.
>+PASS typeof cocoa is "undefined"
>+PASS typeof exportedCocoa is "object"
>+PASS exportedCocoa.taste() is "awesome"
>+PASS successfullyParsed is true
>+
>+TEST COMPLETE
>+
>diff --git a/LayoutTests/js/dom/module-inline-simple.html b/LayoutTests/js/dom/module-inline-simple.html
>new file mode 100644
>index 0000000000000000000000000000000000000000..a3ddd53227eff831599e2537627665aa35cbb854
>--- /dev/null
>+++ b/LayoutTests/js/dom/module-inline-simple.html
>@@ -0,0 +1,30 @@
>+<!DOCTYPE HTML>
>+<html>
>+<head>
>+<script src="../../resources/js-test-pre.js"></script>
>+</head>
>+<body>
>+<script>
>+description('Test inlined module.');
>+
>+// Module will be executed asynchronously.
>+window.jsTestIsAsync = true;
>+</script>
>+<script>
>+debug('Module is not executed yet.');
>+</script>
>+<script src="../../resources/js-test-post.js"></script>
>+<script type="module">
>+import Cocoa from "./script-tests/module-inline-simple.js";
>+var cocoa = new Cocoa();
>+
>+debug("Module execution is confined in the module environment.");
>+shouldBeEqualToString("typeof cocoa", "undefined");
>+
>+window.exportedCocoa = cocoa;
>+shouldBeEqualToString("typeof exportedCocoa", "object");
>+shouldBeEqualToString("exportedCocoa.taste()", "awesome");
>+finishJSTest();
>+</script>
>+</body>
>+</html>
>diff --git a/LayoutTests/js/dom/module-load-event-expected.txt b/LayoutTests/js/dom/module-load-event-expected.txt
>new file mode 100644
>index 0000000000000000000000000000000000000000..586266802da57c758ce3e4a2f31d7890d0e5b7d5
>--- /dev/null
>+++ b/LayoutTests/js/dom/module-load-event-expected.txt
>@@ -0,0 +1,11 @@
>+Test module execution order between tags.
>+
>+On success, you will see a series of "PASS" messages, followed by "TEST COMPLETE".
>+
>+
>+Module is not executed yet.
>+Executing an inlined module.
>+PASS successfullyParsed is true
>+
>+TEST COMPLETE
>+
>diff --git a/LayoutTests/js/dom/module-load-event-with-src-expected.txt b/LayoutTests/js/dom/module-load-event-with-src-expected.txt
>new file mode 100644
>index 0000000000000000000000000000000000000000..e8a2f9b99616ff470aee2a45e72bbda6efacd409
>--- /dev/null
>+++ b/LayoutTests/js/dom/module-load-event-with-src-expected.txt
>@@ -0,0 +1,11 @@
>+Test script.onload will be fired when the module tag with src loads and executes.
>+
>+On success, you will see a series of "PASS" messages, followed by "TEST COMPLETE".
>+
>+
>+Module is not executed yet.
>+Executing a module with src attribute.
>+PASS successfullyParsed is true
>+
>+TEST COMPLETE
>+
>diff --git a/LayoutTests/js/dom/module-load-event-with-src.html b/LayoutTests/js/dom/module-load-event-with-src.html
>new file mode 100644
>index 0000000000000000000000000000000000000000..783a237458b320c993b7283471fbc261f7900e5e
>--- /dev/null
>+++ b/LayoutTests/js/dom/module-load-event-with-src.html
>@@ -0,0 +1,16 @@
>+<!DOCTYPE HTML>
>+<html>
>+<head>
>+<script src="../../resources/js-test-pre.js"></script>
>+</head>
>+<body>
>+<script>
>+description('Test script.onload will be fired when the module tag with src loads and executes.');
>+// Module will be executed asynchronously.
>+window.jsTestIsAsync = true;
>+debug('Module is not executed yet.');
>+</script>
>+<script src="../../resources/js-test-post.js"></script>
>+<script type="module" onload="finishJSTest()" src="script-tests/module-load-event-with-src.js"></script>
>+</body>
>+</html>
>diff --git a/LayoutTests/js/dom/module-load-event.html b/LayoutTests/js/dom/module-load-event.html
>new file mode 100644
>index 0000000000000000000000000000000000000000..764d4acbd44a7761a200223af810558cdef053d5
>--- /dev/null
>+++ b/LayoutTests/js/dom/module-load-event.html
>@@ -0,0 +1,18 @@
>+<!DOCTYPE HTML>
>+<html>
>+<head>
>+<script src="../../resources/js-test-pre.js"></script>
>+</head>
>+<body>
>+<script>
>+description('Test module execution order between tags.');
>+// Module will be executed asynchronously.
>+window.jsTestIsAsync = true;
>+debug('Module is not executed yet.');
>+</script>
>+<script src="../../resources/js-test-post.js"></script>
>+<script type="module" onload="finishJSTest()">
>+debug('Executing an inlined module.');
>+</script>
>+</body>
>+</html>
>diff --git a/LayoutTests/js/dom/module-load-same-module-from-different-entry-point-dynamic-expected.txt b/LayoutTests/js/dom/module-load-same-module-from-different-entry-point-dynamic-expected.txt
>new file mode 100644
>index 0000000000000000000000000000000000000000..71ab49d1497624df22e034797b39aa8ec8694ecc
>--- /dev/null
>+++ b/LayoutTests/js/dom/module-load-same-module-from-different-entry-point-dynamic-expected.txt
>@@ -0,0 +1,13 @@
>+2 different module tag will attempt to load the same module from a dynamically generated tag
>+
>+On success, you will see a series of "PASS" messages, followed by "TEST COMPLETE".
>+
>+
>+Currently, this is not defined in the spec. This issue should be fixed in the future.
>+Module is not executed yet.
>+Executing module-load-same-module-from-different-entry-point.js.
>+Executing the module.
>+PASS successfullyParsed is true
>+
>+TEST COMPLETE
>+
>diff --git a/LayoutTests/js/dom/module-load-same-module-from-different-entry-point-dynamic.html b/LayoutTests/js/dom/module-load-same-module-from-different-entry-point-dynamic.html
>new file mode 100644
>index 0000000000000000000000000000000000000000..a46611c0102c2195000be334290efa350a9464b4
>--- /dev/null
>+++ b/LayoutTests/js/dom/module-load-same-module-from-different-entry-point-dynamic.html
>@@ -0,0 +1,25 @@
>+<!DOCTYPE HTML>
>+<html>
>+<head>
>+<script src="../../resources/js-test-pre.js"></script>
>+</head>
>+<body>
>+<script>
>+description('2 different module tag will attempt to load the same module from a dynamically generated tag');
>+debug('Currently, this is not defined in the spec. This issue should be fixed in the future.');
>+// Module will be executed asynchronously.
>+window.jsTestIsAsync = true;
>+debug('Module is not executed yet.');
>+</script>
>+<script src="../../resources/js-test-post.js"></script>
>+<script type="module">
>+import "./script-tests/module-load-same-module-from-different-entry-point.js"
>+debug('Executing the module.');
>+var element = document.createElement("script");
>+element.type = "module";
>+element.innerText = "script-tests/module-load-same-module-from-different-entry-point.js";
>+element.onerror = finishJSTest();
>+document.body.appendChild(element);
>+</script>
>+</body>
>+</html>
>diff --git a/LayoutTests/js/dom/module-load-same-module-from-different-entry-point-expected.txt b/LayoutTests/js/dom/module-load-same-module-from-different-entry-point-expected.txt
>new file mode 100644
>index 0000000000000000000000000000000000000000..b0f98fccb6fafa06447e3032ef06d982027f251d
>--- /dev/null
>+++ b/LayoutTests/js/dom/module-load-same-module-from-different-entry-point-expected.txt
>@@ -0,0 +1,14 @@
>+2 different module tag will attempt to load the same module
>+
>+On success, you will see a series of "PASS" messages, followed by "TEST COMPLETE".
>+
>+
>+Currently, this is not defined in the spec. This issue should be fixed in the future.
>+Module is not executed yet.
>+Executing module-load-same-module-from-different-entry-point.js.
>+Executing the module.
>+Executing the module.
>+PASS successfullyParsed is true
>+
>+TEST COMPLETE
>+
>diff --git a/LayoutTests/js/dom/module-load-same-module-from-different-entry-point.html b/LayoutTests/js/dom/module-load-same-module-from-different-entry-point.html
>new file mode 100644
>index 0000000000000000000000000000000000000000..ac46c9482b767bb319418211f6c24d8e58d42c12
>--- /dev/null
>+++ b/LayoutTests/js/dom/module-load-same-module-from-different-entry-point.html
>@@ -0,0 +1,24 @@
>+<!DOCTYPE HTML>
>+<html>
>+<head>
>+<script src="../../resources/js-test-pre.js"></script>
>+</head>
>+<body>
>+<script>
>+description('2 different module tag will attempt to load the same module');
>+debug('Currently, this is not defined in the spec. This issue should be fixed in the future.');
>+// Module will be executed asynchronously.
>+window.jsTestIsAsync = true;
>+debug('Module is not executed yet.');
>+</script>
>+<script src="../../resources/js-test-post.js"></script>
>+<script type="module">
>+import "./script-tests/module-load-same-module-from-different-entry-point.js"
>+debug('Executing the module.');
>+</script>
>+<script type="module" onload="finishJSTest()">
>+import "./script-tests/module-load-same-module-from-different-entry-point.js"
>+debug('Executing the module.');
>+</script>
>+</body>
>+</html>
>diff --git a/LayoutTests/js/dom/module-not-found-error-event-expected.txt b/LayoutTests/js/dom/module-not-found-error-event-expected.txt
>new file mode 100644
>index 0000000000000000000000000000000000000000..92792d8fcd22500ed460604e582eebcd0082fbdf
>--- /dev/null
>+++ b/LayoutTests/js/dom/module-not-found-error-event-expected.txt
>@@ -0,0 +1,10 @@
>+Test script.onerror will be fired when the resource specified by the import declaration in the inlined module is not found.
>+
>+On success, you will see a series of "PASS" messages, followed by "TEST COMPLETE".
>+
>+
>+Module is not executed yet.
>+PASS successfullyParsed is true
>+
>+TEST COMPLETE
>+
>diff --git a/LayoutTests/js/dom/module-not-found-error-event-with-src-and-import-expected.txt b/LayoutTests/js/dom/module-not-found-error-event-with-src-and-import-expected.txt
>new file mode 100644
>index 0000000000000000000000000000000000000000..748787501a1292768109187907afc47dfb6d2893
>--- /dev/null
>+++ b/LayoutTests/js/dom/module-not-found-error-event-with-src-and-import-expected.txt
>@@ -0,0 +1,10 @@
>+Test script.onerror will be fired when the resource specified by the import declaration in the dependent module is not found.
>+
>+On success, you will see a series of "PASS" messages, followed by "TEST COMPLETE".
>+
>+
>+Module is not executed yet.
>+PASS successfullyParsed is true
>+
>+TEST COMPLETE
>+
>diff --git a/LayoutTests/js/dom/module-not-found-error-event-with-src-and-import.html b/LayoutTests/js/dom/module-not-found-error-event-with-src-and-import.html
>new file mode 100644
>index 0000000000000000000000000000000000000000..58266f7f79be5c69a162a098472ae54e87d529fc
>--- /dev/null
>+++ b/LayoutTests/js/dom/module-not-found-error-event-with-src-and-import.html
>@@ -0,0 +1,21 @@
>+<!DOCTYPE HTML>
>+<html>
>+<head>
>+<script src="../../resources/js-test-pre.js"></script>
>+</head>
>+<body>
>+<script>
>+description('Test script.onerror will be fired when the resource specified by the import declaration in the dependent module is not found.');
>+// Module will be executed asynchronously.
>+window.jsTestIsAsync = true;
>+debug('Module is not executed yet.');
>+function onError()
>+{
>+    successfullyParsed = true;
>+    finishJSTest()
>+}
>+</script>
>+<script src="../../resources/js-test-post.js"></script>
>+<script type="module" src="script-tests/module-not-found-error-event-with-src-and-import.js" onerror="onError()"></script>
>+</body>
>+</html>
>diff --git a/LayoutTests/js/dom/module-not-found-error-event-with-src-expected.txt b/LayoutTests/js/dom/module-not-found-error-event-with-src-expected.txt
>new file mode 100644
>index 0000000000000000000000000000000000000000..b80d15dfe6d09bfc6b8583a48dec6dcb1b5b1414
>--- /dev/null
>+++ b/LayoutTests/js/dom/module-not-found-error-event-with-src-expected.txt
>@@ -0,0 +1,10 @@
>+Test script.onerror will be fired when the resource specified by "src" is not found.
>+
>+On success, you will see a series of "PASS" messages, followed by "TEST COMPLETE".
>+
>+
>+Module is not executed yet.
>+PASS successfullyParsed is true
>+
>+TEST COMPLETE
>+
>diff --git a/LayoutTests/js/dom/module-not-found-error-event-with-src.html b/LayoutTests/js/dom/module-not-found-error-event-with-src.html
>new file mode 100644
>index 0000000000000000000000000000000000000000..22d1ec8b87aa67fbb2e75371faa216947e63ceaa
>--- /dev/null
>+++ b/LayoutTests/js/dom/module-not-found-error-event-with-src.html
>@@ -0,0 +1,21 @@
>+<!DOCTYPE HTML>
>+<html>
>+<head>
>+<script src="../../resources/js-test-pre.js"></script>
>+</head>
>+<body>
>+<script>
>+description('Test script.onerror will be fired when the resource specified by "src" is not found.');
>+// Module will be executed asynchronously.
>+window.jsTestIsAsync = true;
>+debug('Module is not executed yet.');
>+function onError()
>+{
>+    successfullyParsed = true;
>+    finishJSTest()
>+}
>+</script>
>+<script src="../../resources/js-test-post.js"></script>
>+<script type="module" src="not-found.js" onerror="onError()"></script>
>+</body>
>+</html>
>diff --git a/LayoutTests/js/dom/module-not-found-error-event.html b/LayoutTests/js/dom/module-not-found-error-event.html
>new file mode 100644
>index 0000000000000000000000000000000000000000..01f42458673d71883a222e129ab0ccfaa4e8a2c7
>--- /dev/null
>+++ b/LayoutTests/js/dom/module-not-found-error-event.html
>@@ -0,0 +1,24 @@
>+<!DOCTYPE HTML>
>+<html>
>+<head>
>+<script src="../../resources/js-test-pre.js"></script>
>+</head>
>+<body>
>+<script>
>+description('Test script.onerror will be fired when the resource specified by the import declaration in the inlined module is not found.');
>+// Module will be executed asynchronously.
>+window.jsTestIsAsync = true;
>+debug('Module is not executed yet.');
>+function onError()
>+{
>+    successfullyParsed = true;
>+    finishJSTest()
>+}
>+</script>
>+<script src="../../resources/js-test-post.js"></script>
>+<script type="module" onerror="onError()">
>+import "./not-found.js";
>+testFailed('executed');
>+</script>
>+</body>
>+</html>
>diff --git a/LayoutTests/js/dom/module-src-current-script-expected.txt b/LayoutTests/js/dom/module-src-current-script-expected.txt
>new file mode 100644
>index 0000000000000000000000000000000000000000..3136777c2ebdbc830fb4ec89ab69f203fdc111cf
>--- /dev/null
>+++ b/LayoutTests/js/dom/module-src-current-script-expected.txt
>@@ -0,0 +1,12 @@
>+Test document.currentScript should be null when executing the module with the src attribute.
>+
>+On success, you will see a series of "PASS" messages, followed by "TEST COMPLETE".
>+
>+
>+Module is not executed yet.
>+Module execution is confined in the module environment.
>+PASS document.currentScript is null
>+PASS successfullyParsed is true
>+
>+TEST COMPLETE
>+
>diff --git a/LayoutTests/js/dom/module-src-current-script.html b/LayoutTests/js/dom/module-src-current-script.html
>new file mode 100644
>index 0000000000000000000000000000000000000000..dadc6d2383ce2dfacd69b2d7eca27e935116cb18
>--- /dev/null
>+++ b/LayoutTests/js/dom/module-src-current-script.html
>@@ -0,0 +1,19 @@
>+<!DOCTYPE HTML>
>+<html>
>+<head>
>+<script src="../../resources/js-test-pre.js"></script>
>+</head>
>+<body>
>+<script>
>+description('Test document.currentScript should be null when executing the module with the src attribute.');
>+
>+// Module will be executed asynchronously.
>+window.jsTestIsAsync = true;
>+</script>
>+<script>
>+debug('Module is not executed yet.');
>+</script>
>+<script src="../../resources/js-test-post.js"></script>
>+<script type="module" src="./script-tests/module-src-current-script.js"></script>
>+</body>
>+</html>
>diff --git a/LayoutTests/js/dom/module-src-dynamic-expected.txt b/LayoutTests/js/dom/module-src-dynamic-expected.txt
>new file mode 100644
>index 0000000000000000000000000000000000000000..3d8b0062490ec72295cff5061a0839e40020cd8a
>--- /dev/null
>+++ b/LayoutTests/js/dom/module-src-dynamic-expected.txt
>@@ -0,0 +1,14 @@
>+Test module with "src" attribute.
>+
>+On success, you will see a series of "PASS" messages, followed by "TEST COMPLETE".
>+
>+
>+Module is not executed yet.
>+Module execution is confined in the module environment.
>+PASS typeof cocoa is "undefined"
>+PASS typeof exportedCocoa is "object"
>+PASS exportedCocoa.taste() is "nice"
>+PASS successfullyParsed is true
>+
>+TEST COMPLETE
>+
>diff --git a/LayoutTests/js/dom/module-src-dynamic.html b/LayoutTests/js/dom/module-src-dynamic.html
>new file mode 100644
>index 0000000000000000000000000000000000000000..cc559afb7aa081e0c1b435a06a0fb078f1cf8029
>--- /dev/null
>+++ b/LayoutTests/js/dom/module-src-dynamic.html
>@@ -0,0 +1,24 @@
>+<!DOCTYPE HTML>
>+<html>
>+<head>
>+<script src="../../resources/js-test-pre.js"></script>
>+</head>
>+<body>
>+<script>
>+description('Test module with "src" attribute.');
>+
>+// Module will be executed asynchronously.
>+window.jsTestIsAsync = true;
>+</script>
>+<script src="../../resources/js-test-post.js"></script>
>+<script>
>+debug('Module is not executed yet.');
>+(function () {
>+    var element = document.createElement('script');
>+    element.type = 'module';
>+    element.src = './script-tests/module-src-dynamic.js';
>+    document.body.appendChild(element);
>+}());
>+</script>
>+</body>
>+</html>
>diff --git a/LayoutTests/js/dom/module-src-simple-expected.txt b/LayoutTests/js/dom/module-src-simple-expected.txt
>new file mode 100644
>index 0000000000000000000000000000000000000000..3d8b0062490ec72295cff5061a0839e40020cd8a
>--- /dev/null
>+++ b/LayoutTests/js/dom/module-src-simple-expected.txt
>@@ -0,0 +1,14 @@
>+Test module with "src" attribute.
>+
>+On success, you will see a series of "PASS" messages, followed by "TEST COMPLETE".
>+
>+
>+Module is not executed yet.
>+Module execution is confined in the module environment.
>+PASS typeof cocoa is "undefined"
>+PASS typeof exportedCocoa is "object"
>+PASS exportedCocoa.taste() is "nice"
>+PASS successfullyParsed is true
>+
>+TEST COMPLETE
>+
>diff --git a/LayoutTests/js/dom/module-src-simple.html b/LayoutTests/js/dom/module-src-simple.html
>new file mode 100644
>index 0000000000000000000000000000000000000000..406f24e435bb66b487d9bbe3a5c1cba4796cd13c
>--- /dev/null
>+++ b/LayoutTests/js/dom/module-src-simple.html
>@@ -0,0 +1,19 @@
>+<!DOCTYPE HTML>
>+<html>
>+<head>
>+<script src="../../resources/js-test-pre.js"></script>
>+</head>
>+<body>
>+<script>
>+description('Test module with "src" attribute.');
>+
>+// Module will be executed asynchronously.
>+window.jsTestIsAsync = true;
>+</script>
>+<script>
>+debug('Module is not executed yet.');
>+</script>
>+<script src="../../resources/js-test-post.js"></script>
>+<script type="module" src="./script-tests/module-src-simple.js"></script>
>+</body>
>+</html>
>diff --git a/LayoutTests/js/dom/module-type-case-insensitive-expected.txt b/LayoutTests/js/dom/module-type-case-insensitive-expected.txt
>new file mode 100644
>index 0000000000000000000000000000000000000000..77680193d3e25f8303c1d026710a88e9e9c7e9aa
>--- /dev/null
>+++ b/LayoutTests/js/dom/module-type-case-insensitive-expected.txt
>@@ -0,0 +1,11 @@
>+Test that type="module" should be case-insensitive.
>+
>+On success, you will see a series of "PASS" messages, followed by "TEST COMPLETE".
>+
>+
>+Module is not executed yet.
>+Module is loaded.
>+PASS successfullyParsed is true
>+
>+TEST COMPLETE
>+
>diff --git a/LayoutTests/js/dom/module-type-case-insensitive.html b/LayoutTests/js/dom/module-type-case-insensitive.html
>new file mode 100644
>index 0000000000000000000000000000000000000000..dffbacbd6dac85926726156c41ad904e7ea4ce18
>--- /dev/null
>+++ b/LayoutTests/js/dom/module-type-case-insensitive.html
>@@ -0,0 +1,39 @@
>+<!DOCTYPE HTML>
>+<html>
>+<head>
>+<script src="../../resources/js-test-pre.js"></script>
>+</head>
>+<body>
>+<script>
>+description('Test that type="module" should be case-insensitive.');
>+
>+// Module will be executed asynchronously.
>+window.jsTestIsAsync = true;
>+
>+Promise.all([
>+    new Promise(function (resolve) {
>+        window.resolve1 = resolve;
>+    }),
>+    new Promise(function (resolve) {
>+        window.resolve2 = resolve;
>+    }),
>+]).then(function () {
>+    debug('Module is loaded.');
>+    finishJSTest();
>+});
>+debug('Module is not executed yet.');
>+</script>
>+<script src="../../resources/js-test-post.js"></script>
>+
>+<script type="MoDuLe">
>+import Cocoa from "./script-tests/module-inline-simple.js";
>+window.resolve1();
>+</script>
>+
>+<script type="MODULE">
>+import Cocoa from "./script-tests/module-inline-simple.js";
>+window.resolve2();
>+</script>
>+
>+</body>
>+</html>
>diff --git a/LayoutTests/js/dom/module-will-fire-beforeload-expected.txt b/LayoutTests/js/dom/module-will-fire-beforeload-expected.txt
>new file mode 100644
>index 0000000000000000000000000000000000000000..3a8d9708db3e05c4b0103be7dceb0c0071175c75
>--- /dev/null
>+++ b/LayoutTests/js/dom/module-will-fire-beforeload-expected.txt
>@@ -0,0 +1,10 @@
>+Test script.beforeload will be fired when the module tag with src is prepared.
>+
>+On success, you will see a series of "PASS" messages, followed by "TEST COMPLETE".
>+
>+
>+Module is not executed yet.
>+PASS successfullyParsed is true
>+
>+TEST COMPLETE
>+
>diff --git a/LayoutTests/js/dom/module-will-fire-beforeload.html b/LayoutTests/js/dom/module-will-fire-beforeload.html
>new file mode 100644
>index 0000000000000000000000000000000000000000..d6a80e8d491e102dce9281c947e00726f47d43fd
>--- /dev/null
>+++ b/LayoutTests/js/dom/module-will-fire-beforeload.html
>@@ -0,0 +1,16 @@
>+<!DOCTYPE HTML>
>+<html>
>+<head>
>+<script src="../../resources/js-test-pre.js"></script>
>+</head>
>+<body>
>+<script>
>+description('Test script.beforeload will be fired when the module tag with src is prepared.');
>+// Module will be executed asynchronously.
>+window.jsTestIsAsync = true;
>+debug('Module is not executed yet.');
>+</script>
>+<script src="../../resources/js-test-post.js"></script>
>+<script type="module" onbeforeload="finishJSTest()" src="script-tests/module-will-fire-beforeload.js"></script>
>+</body>
>+</html>
>diff --git a/LayoutTests/js/dom/script-tests/module-document-write-src.js b/LayoutTests/js/dom/script-tests/module-document-write-src.js
>new file mode 100644
>index 0000000000000000000000000000000000000000..cdc21ea20b156860345c0fc3f24e298927bdd9d1
>--- /dev/null
>+++ b/LayoutTests/js/dom/script-tests/module-document-write-src.js
>@@ -0,0 +1,2 @@
>+document.write("TEST FAILED");
>+finishJSTest();
>diff --git a/LayoutTests/js/dom/script-tests/module-execution-error-inside-dependent-module-should-be-propagated-to-onerror-throw.js b/LayoutTests/js/dom/script-tests/module-execution-error-inside-dependent-module-should-be-propagated-to-onerror-throw.js
>new file mode 100644
>index 0000000000000000000000000000000000000000..c6c15af2142b4802602ead03700f8bbe01bc2bec
>--- /dev/null
>+++ b/LayoutTests/js/dom/script-tests/module-execution-error-inside-dependent-module-should-be-propagated-to-onerror-throw.js
>@@ -0,0 +1,2 @@
>+debug("Executing the dependent module");
>+throw new Error("out");

Actions: View | Formatted Diff | Diff

Attachments on bug 148897: 260914 | 260987 | 261138 | 261183 | 261547 | 261562 | 261570 | 261672 | 261841 | 261844 | 261852 | 261854 | 261861 | 261880 | 261889 | 261892 | 261893 | 261946 | 286536 | 286556 | 286558 | 287071 | 287124 | 287165 | 287175 | 287176 | 287179 | 287187 | 287223 | 287225 | 287226 | 287227 | 287228 | 287247 | 287253 | 287254 | 287255 | 287257 | 287277 | 287279 | 287292 | 287294 | 287297 | 287300 | 287329 | 287479 | 287504 | 287545 | 287563 | 287596 | 287646 | 287690 | 287698 | 287716 | 287725 | 287727 | 287733 | 287742 | 287743 | 287744 | 287750 | 287764 | 287781 | 287836 | 287843 | 287844 | 287846 | 288049 | 288051 | 288066 | 288389 | 288462 | 291662 | 292487 | 292524 | 293120 | 293531 | 293606 | 294227 | 294478 | 294479 | 294483 | 294488 | 294609 | 294610 | 294611 | 294662 | 294786 | 294802 | 294805 | 294806 | 294813 | 294815 | 294817 | 294818 | 294823 | 294824 | 294826 | 294827 | 294829 | 294830 | 294928 | 294929