[WIP Prototype] ES6 https://html.spec.whatwg.org/#fetch-a-single-module-script implementation

third_party/WebKit/Source/core/loader/modulescript/ModuleTreeLinker.h

+// 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.
+
+#ifndef ModuleTreeLinker_h
+#define ModuleTreeLinker_h
+
+#include "core/dom/Modulator.h"
+#include "platform/weborigin/KURL.h"
+#include "platform/weborigin/KURLHash.h"
+#include "wtf/HashSet.h"
+
+namespace blink {
+
+class ModuleTreeLinkerRegistry;
+
+// A ModuleTreeLinker is responsible for running and keeping intermediate states
+// for "internal module script graph fetching procedure" for a module graph tree
+// node.
+// https://html.spec.whatwg.org/multipage/webappapis.html#internal-module-script-graph-fetching-procedure
+class ModuleTreeLinker final
+    : public GarbageCollectedFinalized<ModuleTreeLinker>,
+      public SingleModuleClient {
+  USING_GARBAGE_COLLECTED_MIXIN(ModuleTreeLinker);
+
+ public:
+  static ModuleTreeLinker* fetch(const KURL&,

[dominicc (has gone to gerrit), 2017/01/11 06:57:15]

WDYT about not coupling the ModuleTreeLinker and ModuleTreeLinkerRegistry
together, but having ModuleTreeLinkerRegistry be a factory for ModuleTreeLinkers
and making ModuleTreeLinkerRegistry have a ModuleTreeClient which (a) removes
the finished linker, (b) calls the client's ModuleTreeClient.

[kouhei (in TOK), 2017/01/17 05:26:13]

Would you give more background on why you prefer the proposed design?

In the proposed design, ModuleTreeLinker doesn't depend on MTLRegistry. We can
separate tests.
However, MTLRegistry test will still depend on MTL impl (unless we cut a factory
interface), and typical MTLClient codepath is slightly harder to follow as the
code reader need to find out that the MTRegistry::MTClient have redirect.

+                                 const KURL& baseURL,
+                                 HashSet<KURL> ancestorList,
+                                 Modulator*,
+                                 ModuleTreeLinkerRegistry*,
+                                 ModuleTreeClient*);
+  virtual ~ModuleTreeLinker() = default;
+  DECLARE_TRACE();
+
+  bool isFetching() const {
+    return State::FetchingSelf <= m_state && m_state < State::Finished;
+  }
+  bool hasFinished() const { return m_state == State::Finished; }
+
+ private:
+  ModuleTreeLinker(HashSet<KURL> ancestorListWithUrl,
+                   Modulator*,
+                   ModuleTreeLinkerRegistry*,
+                   ModuleTreeClient*);
+
+  enum class State {
+    Initial,
+    // Running fetch of the module script corresponding to the target node.
+    FetchingSelf,
+    // Running fetch of descendants of the target node.
+    FetchingDependencies,
+    // Instantiating m_moduleScript and the node descendants.
+    Instantiating,
+    Finished,
+  };
+  void advanceState(State);
+
+  void fetchSelf(const KURL&, const KURL& baseURL);
+  // Implements SingleModuleClient
+  void notifyFinishedSingleModule(ModuleScript*) override;
+
+  void fetchDescendants();
+  void notifyOneDescendantFinished(bool wasSuccess);

[dominicc (has gone to gerrit), 2017/01/11 06:57:15]

In general enums and not bools are more readable at callsites.

[kouhei (in TOK), 2017/01/17 05:26:13]

Done.

+
+  void instantiate();
+  HeapHashSet<Member<ModuleScript>> uninstantiatedInclusiveDescendants();
+
+  class DependencyModuleClient;
+  friend class DependencyModuleClient;
+
+  Member<Modulator> m_modulator;
+  Member<ModuleTreeLinkerRegistry> m_registry;
+  Member<ModuleTreeClient> m_client;
+  HashSet<KURL> m_ancestorListWithUrl;
+  State m_state = State::Initial;
+  Member<ModuleScript> m_moduleScript;
+  size_t m_numIncompleteDescendants = 0;
+  HeapHashSet<Member<DependencyModuleClient>> m_dependencyClients;
+};
+
+}  // namespace blink
+
+#endif