[ES6 modules] Integrate ModuleTreeLinkerRegistry into ModulatorImpl back-plane

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

 // Copyright 2017 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "core/dom/ModulatorImpl.h"
 
 #include "core/dom/Document.h"
 #include "core/dom/ExecutionContext.h"
 #include "core/dom/ModuleMap.h"
 #include "core/dom/ModuleScript.h"
 #include "core/dom/ScriptModuleResolverImpl.h"
 #include "core/dom/TaskRunnerHelper.h"
 #include "core/frame/LocalFrame.h"
 #include "core/loader/modulescript/ModuleScriptFetchRequest.h"
 #include "core/loader/modulescript/ModuleScriptLoaderRegistry.h"
+#include "core/loader/modulescript/ModuleTreeLinkerRegistry.h"
 #include "platform/loader/fetch/ResourceFetcher.h"
 
 namespace blink {
 
 ModulatorImpl* ModulatorImpl::Create(RefPtr<ScriptState> script_state,
                                      Document& document) {
   return new ModulatorImpl(
       std::move(script_state),
       TaskRunnerHelper::Get(TaskType::kNetworking, &document),
       document.Fetcher());
 }
 
 ModulatorImpl::ModulatorImpl(RefPtr<ScriptState> script_state,
                              RefPtr<WebTaskRunner> task_runner,
                              ResourceFetcher* fetcher)
     : script_state_(std::move(script_state)),
       task_runner_(std::move(task_runner)),
       fetcher_(fetcher),
       map_(this, ModuleMap::Create(this)),
       loader_registry_(ModuleScriptLoaderRegistry::Create()),
+      tree_linker_registry_(ModuleTreeLinkerRegistry::Create()),
       script_module_resolver_(ScriptModuleResolverImpl::Create(this)) {
   DCHECK(script_state_);
   DCHECK(task_runner_);
   DCHECK(fetcher_);
 }
 
 ModulatorImpl::~ModulatorImpl() {}
 
 ReferrerPolicy ModulatorImpl::GetReferrerPolicy() {
   return GetExecutionContext()->GetReferrerPolicy();
@@ skipping 22 matching lines @@
   // Step 2. When the internal module script graph fetching procedure
   // asynchronously completes with result, asynchronously complete this
   // algorithm with result.
   // Note: We delegate to ModuleTreeLinker to notify ModuleTreeClient.
 }
 
 void ModulatorImpl::FetchTreeInternal(const ModuleScriptFetchRequest& request,
                                       const AncestorList& ancestor_list,
                                       ModuleGraphLevel level,
                                       ModuleTreeClient* client) {
-  NOTIMPLEMENTED();
+  tree_linker_registry_->Fetch(request, ancestor_list, level, this, client);
 }
 
 void ModulatorImpl::FetchSingle(const ModuleScriptFetchRequest& request,
                                 ModuleGraphLevel level,
                                 SingleModuleClient* client) {
   map_->FetchSingleModuleScript(request, level, client);
 }
 
 void ModulatorImpl::FetchNewSingleModule(
     const ModuleScriptFetchRequest& request,
@@ skipping 45 matching lines @@
 
 inline ExecutionContext* ModulatorImpl::GetExecutionContext() const {
   return ExecutionContext::From(script_state_.Get());
 }
 
 DEFINE_TRACE(ModulatorImpl) {
   Modulator::Trace(visitor);
   visitor->Trace(fetcher_);
   visitor->Trace(map_);
   visitor->Trace(loader_registry_);
+  visitor->Trace(tree_linker_registry_);
   visitor->Trace(script_module_resolver_);
 }
 
 DEFINE_TRACE_WRAPPERS(ModulatorImpl) {
   visitor->TraceWrappers(map_);
 }
 
 }  // namespace blink