[ES6 modules] Make ModuleMap TraceWrapperBase

third_party/WebKit/Source/core/dom/ModuleMap.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/ModuleMap.h"
 
 #include "core/dom/Modulator.h"
 #include "core/dom/ModuleScript.h"
 #include "core/dom/ScriptModuleResolver.h"
 #include "core/loader/modulescript/ModuleScriptFetchRequest.h"
 #include "core/loader/modulescript/ModuleScriptLoaderClient.h"
 #include "platform/WebTaskRunner.h"
 
 namespace blink {
 
 // Entry struct represents a value in "module map" spec object.
 // https://html.spec.whatwg.org/multipage/webappapis.html#module-map
 class ModuleMap::Entry final : public GarbageCollectedFinalized<Entry>,
+                               public TraceWrapperBase,
                                public ModuleScriptLoaderClient {
   USING_GARBAGE_COLLECTED_MIXIN(ModuleMap::Entry);
 
  public:
   static Entry* create(ModuleMap* map) { return new Entry(map); }
   ~Entry() override {}
 
   DECLARE_TRACE();
+  DECLARE_VIRTUAL_TRACE_WRAPPERS();

[yhirano, 2017/04/05 05:56:46]

ditto

[kouhei (in TOK), 2017/04/05 07:51:43]

Done.

 
   // Notify fetched |m_moduleScript| to the client asynchronously.
   void addClient(SingleModuleClient*);
 
   // This is only to be used from ScriptModuleResolver implementations.
   ModuleScript* getModuleScript() const;
 
  private:
   explicit Entry(ModuleMap*);
 
   void dispatchFinishedNotificationAsync(SingleModuleClient*);
 
   // Implements ModuleScriptLoaderClient
   void notifyNewSingleModuleFinished(ModuleScript*) override;
 
-  Member<ModuleScript> m_moduleScript;
+  TraceWrapperMember<ModuleScript> m_moduleScript;
   Member<ModuleMap> m_map;
 
   // Correspond to the HTML spec: "fetching" state.
   bool m_isFetching = true;
 
   HeapHashSet<Member<SingleModuleClient>> m_clients;
 };
 
-ModuleMap::Entry::Entry(ModuleMap* map) : m_map(map) {
+ModuleMap::Entry::Entry(ModuleMap* map)
+    : m_moduleScript(this, nullptr), m_map(map) {
   DCHECK(m_map);
 }
 
 DEFINE_TRACE(ModuleMap::Entry) {
   visitor->trace(m_moduleScript);
   visitor->trace(m_map);
   visitor->trace(m_clients);
 }
 
+DEFINE_TRACE_WRAPPERS(ModuleMap::Entry) {
+  visitor->traceWrappers(m_moduleScript);
+}
+
 void ModuleMap::Entry::dispatchFinishedNotificationAsync(
     SingleModuleClient* client) {
   m_map->modulator()->taskRunner()->postTask(
       BLINK_FROM_HERE,
       WTF::bind(&SingleModuleClient::notifyModuleLoadFinished,
                 wrapPersistent(client), wrapPersistent(m_moduleScript.get())));
 }
 
 void ModuleMap::Entry::addClient(SingleModuleClient* newClient) {
   DCHECK(!m_clients.contains(newClient));
@@ skipping 30 matching lines @@
 
 ModuleMap::ModuleMap(Modulator* modulator) : m_modulator(modulator) {
   DCHECK(modulator);
 }
 
 DEFINE_TRACE(ModuleMap) {
   visitor->trace(m_map);
   visitor->trace(m_modulator);
 }
 
+DEFINE_TRACE_WRAPPERS(ModuleMap) {
+  for (const auto& it : m_map)
+    visitor->traceWrappers(it.value);
+}
+
 void ModuleMap::fetchSingleModuleScript(const ModuleScriptFetchRequest& request,
                                         ModuleGraphLevel level,
                                         SingleModuleClient* client) {
   // https://html.spec.whatwg.org/#fetch-a-single-module-script
 
   // Step 1. Let moduleMap be module map settings object's module map.
   // Note: This is the ModuleMap.
 
   // Step 2. If moduleMap[url] is "fetching", wait in parallel until that
   // entry's value changes, then queue a task on the networking task source to
   // proceed with running the following steps.
   MapImpl::AddResult result = m_map.insert(request.url(), nullptr);
-  Member<Entry>& entry = result.storedValue->value;
+  TraceWrapperMember<Entry>& entry = result.storedValue->value;
   if (result.isNewEntry) {
-    entry = Entry::create(this);
+    entry = TraceWrapperMember<Entry>(this, Entry::create(this));
 
     // Steps 4-9 loads a new single module script.
     // Delegates to ModuleScriptLoader via Modulator.
     m_modulator->fetchNewSingleModule(request, level, entry);
   }
   DCHECK(entry);
 
   // Step 3. If moduleMap[url] exists, asynchronously complete this algorithm
   // with moduleMap[url], and abort these steps.
   // Step 10. Set moduleMap[url] to module script, and asynchronously complete
   // this algorithm with module script.
   entry->addClient(client);
 }
 
 ModuleScript* ModuleMap::getFetchedModuleScript(const KURL& url) const {
   MapImpl::const_iterator it = m_map.find(url);
   CHECK_NE(it, m_map.end());
   return it->value->getModuleScript();
 }
 
 }  // namespace blink