[wrapper-tracing] Fix WebGL extension and attachment handling

third_party/WebKit/Source/modules/webgl/WebGLFramebuffer.cpp

 /*
  * 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 22 matching lines @@
 namespace blink {
 
 namespace {
 
 class WebGLRenderbufferAttachment final
     : public WebGLFramebuffer::WebGLAttachment {
  public:
   static WebGLFramebuffer::WebGLAttachment* create(WebGLRenderbuffer*);
 
   DECLARE_VIRTUAL_TRACE();
+  DEFINE_INLINE_VIRTUAL_TRACE_WRAPPERS() {
+    visitor->traceWrappers(m_renderbuffer);
+  }
 
  private:
   explicit WebGLRenderbufferAttachment(WebGLRenderbuffer*);
 
   WebGLSharedObject* object() const override;
   bool isSharedObject(WebGLSharedObject*) const override;
   bool valid() const override;
   void onDetached(gpu::gles2::GLES2Interface*) override;
   void attach(gpu::gles2::GLES2Interface*,
               GLenum target,
               GLenum attachment) override;
   void unattach(gpu::gles2::GLES2Interface*,
                 GLenum target,
                 GLenum attachment) override;
 
-  Member<WebGLRenderbuffer> m_renderbuffer;
+  TraceWrapperMember<WebGLRenderbuffer> m_renderbuffer;
 };
 
 WebGLFramebuffer::WebGLAttachment* WebGLRenderbufferAttachment::create(
     WebGLRenderbuffer* renderbuffer) {
   return new WebGLRenderbufferAttachment(renderbuffer);
 }
 
 DEFINE_TRACE(WebGLRenderbufferAttachment) {
   visitor->trace(m_renderbuffer);
   WebGLFramebuffer::WebGLAttachment::trace(visitor);
 }
 
 WebGLRenderbufferAttachment::WebGLRenderbufferAttachment(
     WebGLRenderbuffer* renderbuffer)
-    : m_renderbuffer(renderbuffer) {}
+    : m_renderbuffer(this, renderbuffer) {}
 
 WebGLSharedObject* WebGLRenderbufferAttachment::object() const {
   return m_renderbuffer->object() ? m_renderbuffer.get() : 0;
 }
 
 bool WebGLRenderbufferAttachment::isSharedObject(
     WebGLSharedObject* object) const {
   return object == m_renderbuffer;
 }
 
@@ skipping 19 matching lines @@
 }
 
 class WebGLTextureAttachment final : public WebGLFramebuffer::WebGLAttachment {
  public:
   static WebGLFramebuffer::WebGLAttachment* create(WebGLTexture*,
                                                    GLenum target,
                                                    GLint level,
                                                    GLint layer);
 
   DECLARE_VIRTUAL_TRACE();
+  DEFINE_INLINE_VIRTUAL_TRACE_WRAPPERS() { visitor->traceWrappers(m_texture); }
 
  private:
   WebGLTextureAttachment(WebGLTexture*,
                          GLenum target,
                          GLint level,
                          GLint layer);
 
   WebGLSharedObject* object() const override;
   bool isSharedObject(WebGLSharedObject*) const override;
   bool valid() const override;
   void onDetached(gpu::gles2::GLES2Interface*) override;
   void attach(gpu::gles2::GLES2Interface*,
               GLenum target,
               GLenum attachment) override;
   void unattach(gpu::gles2::GLES2Interface*,
                 GLenum target,
                 GLenum attachment) override;
 
-  Member<WebGLTexture> m_texture;
+  TraceWrapperMember<WebGLTexture> m_texture;
   GLenum m_target;
   GLint m_level;
   GLint m_layer;
 };
 
 WebGLFramebuffer::WebGLAttachment* WebGLTextureAttachment::create(
     WebGLTexture* texture,
     GLenum target,
     GLint level,
     GLint layer) {
   return new WebGLTextureAttachment(texture, target, level, layer);
 }
 
 DEFINE_TRACE(WebGLTextureAttachment) {
   visitor->trace(m_texture);
   WebGLFramebuffer::WebGLAttachment::trace(visitor);
 }
 
 WebGLTextureAttachment::WebGLTextureAttachment(WebGLTexture* texture,
                                                GLenum target,
                                                GLint level,
                                                GLint layer)
-    : m_texture(texture), m_target(target), m_level(level), m_layer(layer) {}
+    : m_texture(this, texture),
+      m_target(target),
+      m_level(level),
+      m_layer(layer) {}
 
 WebGLSharedObject* WebGLTextureAttachment::object() const {
   return m_texture->object() ? m_texture.get() : 0;
 }
 
 bool WebGLTextureAttachment::isSharedObject(WebGLSharedObject* object) const {
   return object == m_texture;
 }
 
 bool WebGLTextureAttachment::valid() const {
@@ skipping 368 matching lines @@
   }
 }
 
 DEFINE_TRACE(WebGLFramebuffer) {
   visitor->trace(m_attachments);
   WebGLContextObject::trace(visitor);
 }
 
 DEFINE_TRACE_WRAPPERS(WebGLFramebuffer) {
   for (const auto& attachment : m_attachments) {
-    visitor->traceWrappers(attachment.value->object());
+    visitor->traceWrappers(attachment.value);
   }
   WebGLContextObject::traceWrappers(visitor);
 }
 
 }  // namespace blink