[wrapper-tracing] Fix WebGL extension and attachment handling

third_party/WebKit/Source/modules/webgl/WebGLRenderingContextBase.h

 /*
  * Copyright (C) 2009 Apple Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
@@ skipping 788 matching lines @@
   unsigned long m_onePlusMaxNonDefaultTextureUnit;
 
   std::unique_ptr<Extensions3DUtil> m_extensionsUtil;
 
   enum ExtensionFlags {
     ApprovedExtension = 0x00,
     // Extension that is behind the draft extensions runtime flag:
     DraftExtension = 0x01,
   };
 
-  class ExtensionTracker : public GarbageCollected<ExtensionTracker> {
+  class ExtensionTracker : public GarbageCollected<ExtensionTracker>,
+                           public TraceWrapperBase {
    public:
     ExtensionTracker(ExtensionFlags flags, const char* const* prefixes)
         : m_draft(flags & DraftExtension), m_prefixes(prefixes) {}
 
     bool draft() const { return m_draft; }
 
     const char* const* prefixes() const;
     bool matchesNameWithPrefixes(const String&) const;
 
     virtual WebGLExtension* getExtension(WebGLRenderingContextBase*) = 0;
@@ skipping 15 matching lines @@
   class TypedExtensionTracker final : public ExtensionTracker {
    public:
     static TypedExtensionTracker<T>* create(Member<T>& extensionField,
                                             ExtensionFlags flags,
                                             const char* const* prefixes) {
       return new TypedExtensionTracker<T>(extensionField, flags, prefixes);
     }
 
     WebGLExtension* getExtension(WebGLRenderingContextBase* context) override {
       if (!m_extension) {
         m_extension = T::create(context);

[Michael Lippautz, 2016/11/30 21:07:38]

This lazy creation is the reason we need to trace the tracker (for incremental
tracing).

[haraken, 2016/12/01 01:44:14]

Makes sense. We should not do anything non-trivial in traceWrappers (and
Oilpan's trace).

         m_extensionField = m_extension;
       }
 
       return m_extension;
     }
 
     bool supported(WebGLRenderingContextBase* context) const override {
       return T::supported(context);
     }
 
     const char* extensionName() const override { return T::extensionName(); }
 
     void loseExtension(bool force) override {
       if (m_extension) {
         m_extension->lose(force);
         if (m_extension->isLost())
           m_extension = nullptr;
       }
     }
 
     WebGLExtension* getExtensionObjectIfAlreadyEnabled() override {
       return m_extension;
     }
 
     DEFINE_INLINE_VIRTUAL_TRACE() {
       visitor->trace(m_extension);
       ExtensionTracker::trace(visitor);
     }
 
+    DEFINE_INLINE_VIRTUAL_TRACE_WRAPPERS() {
+      visitor->traceWrappers(m_extension);
+    }
+
    private:
     TypedExtensionTracker(Member<T>& extensionField,
                           ExtensionFlags flags,
                           const char* const* prefixes)
-        : ExtensionTracker(flags, prefixes), m_extensionField(extensionField) {}
+        : ExtensionTracker(flags, prefixes),
+          m_extensionField(extensionField),
+          m_extension(this, nullptr) {}

[Michael Lippautz, 2016/11/30 21:07:38]

IIUC, then the TypedExtensionTracker should lazily create the extension, keep a
reference itself (which is the one we track for wrapper tracing), and announce
it to the parent reference provided.

[Ken Russell (switch to Gerrit), 2016/12/02 02:12:26]

Yes, I think that's right. Sorry for the complexity here. Some of this will be
changed in the fix for http://crbug.com/666061 / http://crbug.com/537054 .

 
     GC_PLUGIN_IGNORE("http://crbug.com/519953")
     Member<T>& m_extensionField;
     // ExtensionTracker holds it's own reference to the extension to ensure
     // that it is not deleted before this object's destructor is called
-    Member<T> m_extension;
+    TraceWrapperMember<T> m_extension;
   };
 
   bool m_extensionEnabled[WebGLExtensionNameCount];
   HeapVector<TraceWrapperMember<ExtensionTracker>> m_extensions;
 
   template <typename T>
   void registerExtension(Member<T>& extensionPtr,
                          ExtensionFlags flags = ApprovedExtension,
                          const char* const* prefixes = nullptr) {
     m_extensions.append(TraceWrapperMember<ExtensionTracker>(
@@ skipping 772 matching lines @@
                   context,
                   context->is3d(),
                   context.is3d());
 
 }  // namespace blink
 
 WTF_ALLOW_MOVE_INIT_AND_COMPARE_WITH_MEM_FUNCTIONS(
     blink::WebGLRenderingContextBase::TextureUnitState);
 
 #endif  // WebGLRenderingContextBase_h