Use wrapper tracing for worklets.

third_party/WebKit/Source/modules/compositorworker/AnimationWorkletGlobalScope.h

 // 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.
 
 #ifndef AnimationWorkletGlobalScope_h
 #define AnimationWorkletGlobalScope_h
 
 #include "bindings/core/v8/ScriptValue.h"
 #include "core/workers/ThreadedWorkletGlobalScope.h"
 #include "modules/compositorworker/Animator.h"
 #include "modules/compositorworker/AnimatorDefinition.h"
+#include "platform/bindings/ScriptWrappable.h"
 
 namespace blink {
 
 class ExceptionState;
 
 class AnimationWorkletGlobalScope : public ThreadedWorkletGlobalScope {
   DEFINE_WRAPPERTYPEINFO();
 
  public:
   static AnimationWorkletGlobalScope* Create(const KURL&,
                                              const String& user_agent,
                                              PassRefPtr<SecurityOrigin>,
                                              v8::Isolate*,
                                              WorkerThread*);
   ~AnimationWorkletGlobalScope() override;
   DECLARE_TRACE();
-
-  void Dispose() final;
+  DECLARE_TRACE_WRAPPERS();
 
   void registerAnimator(const String& name,
                         const ScriptValue& ctorValue,
                         ExceptionState&);
 
   Animator* CreateInstance(const String& name);
 
  private:
   AnimationWorkletGlobalScope(const KURL&,
                               const String& user_agent,
                               PassRefPtr<SecurityOrigin>,
                               v8::Isolate*,
                               WorkerThread*);
 
-  typedef HeapHashMap<String, Member<AnimatorDefinition>> DefinitionMap;
-  DefinitionMap m_animatorDefinitions;
+  typedef HeapHashMap<String, TraceWrapperMember<AnimatorDefinition>>
+      DefinitionMap;
+  DefinitionMap animator_definitions_;
 
-  typedef HeapVector<Member<Animator>> AnimatorList;
-  AnimatorList m_animators;
+  typedef HeapVector<TraceWrapperMember<Animator>> AnimatorList;
+  AnimatorList animators_;

[haraken, 2017/05/25 04:22:12]

Do you need to trace both animator_definitions_ and animators_? It's harmless to
trace both but it's sufficient to trace AnimatorDefinition once. Maybe would it
be sufficient to trace only animators_? Then the Animator object will trace into
the corresponding AnimatorDefinition.

[majidvp, 2017/05/25 20:16:57]

hmmmm, I think it is better to trace them both here. 

If you want to avoid overhead of tracing things twice (*) then I propose to not
trace the definition from animator. My reasoning is that both animators and
definitions are owned by the scope. The animator reference to its definition is
not owning one. So it seems more natural to trace along the ownership graph.

(*) I am not sure why we care about the tracing cost. In particular, for oilpan
tracing it is very typical to have the
same object being traced via Member<> from multiple path and that
is not very concerning. Is there anything special about wrapper
tracing to warrant being careful as opposed to a simpler guideline
of trace every wrapper.

 };
 
 }  // namespace blink
 
 #endif  // AnimationWorkletGlobalScope_h