Use wrapper tracing for worklets.

third_party/WebKit/Source/modules/webaudio/AudioWorkletGlobalScope.cpp

 // Copyright 2016 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 "modules/webaudio/AudioWorkletGlobalScope.h"
 
 #include "bindings/core/v8/ToV8ForCore.h"
 #include "bindings/core/v8/V8BindingForCore.h"
 #include "bindings/core/v8/WorkerOrWorkletScriptController.h"
 #include "core/dom/ExceptionCode.h"
@@ skipping 23 matching lines @@
     v8::Isolate* isolate,
     WorkerThread* thread)
     : ThreadedWorkletGlobalScope(url,
                                  user_agent,
                                  std::move(security_origin),
                                  isolate,
                                  thread) {}
 
 AudioWorkletGlobalScope::~AudioWorkletGlobalScope() {}
 
-void AudioWorkletGlobalScope::Dispose() {
-  DCHECK(IsContextThread());
-  processor_definition_map_.clear();
-  processor_instances_.clear();
-  ThreadedWorkletGlobalScope::Dispose();
-}
-
 void AudioWorkletGlobalScope::registerProcessor(
     const String& name,
     const ScriptValue& class_definition,
     ExceptionState& exception_state) {
   DCHECK(IsContextThread());
 
   if (processor_definition_map_.Contains(name)) {
     exception_state.ThrowDOMException(
         kNotSupportedError,
         "A class with name:'" + name + "' is already registered.");
@@ skipping 48 matching lines @@
   }
 
   v8::Local<v8::Function> process_function_local =
       process_value_local.As<v8::Function>();
 
   AudioWorkletProcessorDefinition* definition =
       AudioWorkletProcessorDefinition::Create(
           isolate, name, class_definition_local, process_function_local);
   DCHECK(definition);
 
-  processor_definition_map_.Set(name, definition);
+  processor_definition_map_.Set(
+      name,
+      TraceWrapperMember<AudioWorkletProcessorDefinition>(this, definition));
 }
 
 AudioWorkletProcessor* AudioWorkletGlobalScope::CreateInstance(
     const String& name) {
   DCHECK(IsContextThread());
 
   AudioWorkletProcessorDefinition* definition = FindDefinition(name);
   if (!definition)
     return nullptr;
 
   // V8 object instance construction: this construction process is here to make
   // the AudioWorkletProcessor class a thin wrapper of V8::Object instance.
   v8::Isolate* isolate = ScriptController()->GetScriptState()->GetIsolate();
   v8::Local<v8::Object> instance_local;
   if (!V8ObjectConstructor::NewInstance(isolate,
                                         definition->ConstructorLocal(isolate))
            .ToLocal(&instance_local)) {
     return nullptr;
   }
 
   AudioWorkletProcessor* processor = AudioWorkletProcessor::Create(this, name);
   DCHECK(processor);
 
   processor->SetInstance(isolate, instance_local);
-  processor_instances_.push_back(processor);
+  processor_instances_.push_back(
+      TraceWrapperMember<AudioWorkletProcessor>(this, processor));
 
   return processor;
 }
 
 bool AudioWorkletGlobalScope::Process(AudioWorkletProcessor* processor,
                                       AudioBuffer* input_buffer,
                                       AudioBuffer* output_buffer) {
   CHECK(input_buffer);
   CHECK(output_buffer);
 
@@ skipping 29 matching lines @@
     const String& name) {
   return processor_definition_map_.at(name);
 }
 
 DEFINE_TRACE(AudioWorkletGlobalScope) {
   visitor->Trace(processor_definition_map_);
   visitor->Trace(processor_instances_);
   ThreadedWorkletGlobalScope::Trace(visitor);
 }
 
+DEFINE_TRACE_WRAPPERS(AudioWorkletGlobalScope) {
+  for (auto definition : processor_definition_map_)
+    visitor->TraceWrappers(definition.value);
+
+  for (auto processor : processor_instances_)
+    visitor->TraceWrappers(processor);
+
+  ThreadedWorkletGlobalScope::TraceWrappers(visitor);
+}
+
 }  // namespace blink