Use wrapper tracing for worklets.

third_party/WebKit/Source/modules/compositorworker/AnimationWorkletGlobalScope.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/compositorworker/AnimationWorkletGlobalScope.h"
 
 #include "platform/weborigin/SecurityOrigin.h"
 
 #include "bindings/core/v8/ExceptionState.h"
 #include "bindings/core/v8/WorkerOrWorkletScriptController.h"
@@ skipping 23 matching lines @@
     WorkerThread* thread)
     : ThreadedWorkletGlobalScope(url,
                                  user_agent,
                                  std::move(security_origin),
                                  isolate,
                                  thread) {}
 
 AnimationWorkletGlobalScope::~AnimationWorkletGlobalScope() {}
 
 DEFINE_TRACE(AnimationWorkletGlobalScope) {
-  visitor->Trace(m_animatorDefinitions);
-  visitor->Trace(m_animators);
+  visitor->Trace(animator_definitions_);
+  visitor->Trace(animators_);
   ThreadedWorkletGlobalScope::Trace(visitor);
 }
 
-void AnimationWorkletGlobalScope::Dispose() {
-  DCHECK(IsContextThread());
-  // Clear animators and definitions to avoid reference cycle.
-  m_animatorDefinitions.clear();
-  m_animators.clear();
-  ThreadedWorkletGlobalScope::Dispose();
+DEFINE_TRACE_WRAPPERS(AnimationWorkletGlobalScope) {
+  for (auto animator : animators_)
+    visitor->TraceWrappers(animator);
+
+  for (auto definition : animator_definitions_)
+    visitor->TraceWrappers(definition.value);
 }
 
 void AnimationWorkletGlobalScope::registerAnimator(
     const String& name,
     const ScriptValue& ctorValue,
     ExceptionState& exceptionState) {
   DCHECK(IsContextThread());
-  if (m_animatorDefinitions.Contains(name)) {
+  if (animator_definitions_.Contains(name)) {
     exceptionState.ThrowDOMException(
         kNotSupportedError,
         "A class with name:'" + name + "' is already registered.");
     return;
   }
 
   if (name.IsEmpty()) {
     exceptionState.ThrowTypeError("The empty string is not a valid name.");
     return;
   }
@@ skipping 38 matching lines @@
   if (!animateValue->IsFunction()) {
     exceptionState.ThrowTypeError(
         "The 'animate' property on the prototype is not a function.");
     return;
   }
 
   v8::Local<v8::Function> animate = v8::Local<v8::Function>::Cast(animateValue);
 
   AnimatorDefinition* definition =
       new AnimatorDefinition(isolate, constructor, animate);
-  m_animatorDefinitions.Set(name, definition);
+  animator_definitions_.Set(
+      name, TraceWrapperMember<AnimatorDefinition>(this, definition));
 
   // Immediately instantiate an animator for the registered definition.
   // TODO(majidvp): Remove this once you add alternative way to instantiate
-  m_animators.push_back(CreateInstance(name));
+  Animator* animator = CreateInstance(name);
+  animators_.push_back(TraceWrapperMember<Animator>(this, animator));
 }
 
 Animator* AnimationWorkletGlobalScope::CreateInstance(const String& name) {
   DCHECK(IsContextThread());
-  AnimatorDefinition* definition = m_animatorDefinitions.at(name);
+  AnimatorDefinition* definition = animator_definitions_.at(name);
   if (!definition)
     return nullptr;
 
   v8::Isolate* isolate = ScriptController()->GetScriptState()->GetIsolate();
   v8::Local<v8::Function> constructor = definition->ConstructorLocal(isolate);
   DCHECK(!IsUndefinedOrNull(constructor));
 
   v8::Local<v8::Object> instance;
   if (!V8ObjectConstructor::NewInstance(isolate, constructor)
            .ToLocal(&instance))
     return nullptr;
 
   return new Animator(isolate, definition, instance);
 }
 
 }  // namespace blink