[wrapper-tracing] WebGL and friends: Add write barriers

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 12 matching lines @@
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #ifndef WebGLRenderingContextBase_h
 #define WebGLRenderingContextBase_h
 
 #include "bindings/core/v8/Nullable.h"
 #include "bindings/core/v8/ScriptState.h"
 #include "bindings/core/v8/ScriptValue.h"
 #include "bindings/core/v8/ScriptWrappable.h"
+#include "bindings/core/v8/ScriptWrappableVisitor.h"
 #include "core/CoreExport.h"
 #include "core/dom/DOMTypedArray.h"
 #include "core/dom/TypedFlexibleArrayBufferView.h"
 #include "core/html/canvas/CanvasContextCreationAttributes.h"
 #include "core/html/canvas/CanvasRenderingContext.h"
 #include "core/layout/ContentChangeType.h"
 #include "modules/webgl/WebGLContextAttributes.h"
 #include "modules/webgl/WebGLExtensionName.h"
 #include "modules/webgl/WebGLTexture.h"
 #include "modules/webgl/WebGLVertexArrayObjectBase.h"
@@ skipping 536 matching lines @@
 
   DECLARE_VIRTUAL_TRACE_WRAPPERS();
 
   // Returns approximate gpu memory allocated per pixel.
   int externallyAllocatedBytesPerPixel() override;
 
   class TextureUnitState {
     DISALLOW_NEW_EXCEPT_PLACEMENT_NEW();
 
    public:
-    Member<WebGLTexture> m_texture2DBinding;
-    Member<WebGLTexture> m_textureCubeMapBinding;
-    Member<WebGLTexture> m_texture3DBinding;
-    Member<WebGLTexture> m_texture2DArrayBinding;
+    TraceWrapperMember<WebGLTexture> m_texture2DBinding;
+    TraceWrapperMember<WebGLTexture> m_textureCubeMapBinding;
+    TraceWrapperMember<WebGLTexture> m_texture3DBinding;
+    TraceWrapperMember<WebGLTexture> m_texture2DArrayBinding;
 
     DECLARE_TRACE();
+    DECLARE_TRACE_WRAPPERS();
   };
 
   PassRefPtr<Image> getImage(AccelerationHint, SnapshotReason) const override;
   void setFilterQuality(SkFilterQuality) override;
   bool isWebGL2OrHigher() { return version() >= 2; }
 
   void getHTMLOrOffscreenCanvas(HTMLCanvasElementOrOffscreenCanvas&) const;
 
   void commit(ExceptionState&);
 
@@ skipping 99 matching lines @@
   // was lost. For better portability we always defer the dispatch of the event.
   Timer<WebGLRenderingContextBase> m_dispatchContextLostEventTimer;
   bool m_restoreAllowed;
   Timer<WebGLRenderingContextBase> m_restoreTimer;
 
   bool m_markedCanvasDirty;
   HeapHashSet<WeakMember<WebGLContextObject>> m_contextObjects;
 
   // List of bound VBO's. Used to maintain info about sizes for ARRAY_BUFFER and
   // stored values for ELEMENT_ARRAY_BUFFER
-  Member<WebGLBuffer> m_boundArrayBuffer;
+  TraceWrapperMember<WebGLBuffer> m_boundArrayBuffer;
 
   Member<WebGLVertexArrayObjectBase> m_defaultVertexArrayObject;
-  Member<WebGLVertexArrayObjectBase> m_boundVertexArrayObject;
+  TraceWrapperMember<WebGLVertexArrayObjectBase> m_boundVertexArrayObject;
   void setBoundVertexArrayObject(WebGLVertexArrayObjectBase*);
 
   enum VertexAttribValueType {
     Float32ArrayType,
     Int32ArrayType,
     Uint32ArrayType,
   };
 
   Vector<VertexAttribValueType> m_vertexAttribType;
   unsigned m_maxVertexAttribs;
   void setVertexAttribType(GLuint index, VertexAttribValueType);
 
-  Member<WebGLProgram> m_currentProgram;
-  Member<WebGLFramebuffer> m_framebufferBinding;
-  Member<WebGLRenderbuffer> m_renderbufferBinding;
+  TraceWrapperMember<WebGLProgram> m_currentProgram;
+  TraceWrapperMember<WebGLFramebuffer> m_framebufferBinding;
+  TraceWrapperMember<WebGLRenderbuffer> m_renderbufferBinding;
 
   HeapVector<TextureUnitState> m_textureUnits;
   unsigned long m_activeTextureUnit;
 
   Vector<GLenum> m_compressedTextureFormats;
 
   // Fixed-size cache of reusable image buffers for video texImage2D calls.
   class LRUImageBufferCache {
    public:
     LRUImageBufferCache(int capacity);
@@ skipping 134 matching lines @@
         : ExtensionTracker(flags, prefixes), m_extensionField(extensionField) {}
 
     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;
   };
 
   bool m_extensionEnabled[WebGLExtensionNameCount];
-  HeapVector<Member<ExtensionTracker>> m_extensions;
+  HeapVector<TraceWrapperMember<ExtensionTracker>> m_extensions;
 
   template <typename T>
   void registerExtension(Member<T>& extensionPtr,
                          ExtensionFlags flags = ApprovedExtension,
                          const char* const* prefixes = nullptr) {
-    m_extensions.append(
-        TypedExtensionTracker<T>::create(extensionPtr, flags, prefixes));
+    m_extensions.append(TraceWrapperMember<ExtensionTracker>(
+        this, TypedExtensionTracker<T>::create(extensionPtr, flags, prefixes)));
   }
 
   bool extensionSupportedAndAllowed(const ExtensionTracker*);
 
   inline bool extensionEnabled(WebGLExtensionName name) {
     return m_extensionEnabled[name];
   }
 
   // ScopedDrawingBufferBinder is used for
   // ReadPixels/CopyTexImage2D/CopySubImage2D to read from a multisampled
@@ skipping 645 matching lines @@
                   context,
                   context->is3d(),
                   context.is3d());
 
 }  // namespace blink
 
 WTF_ALLOW_MOVE_INIT_AND_COMPARE_WITH_MEM_FUNCTIONS(
     blink::WebGLRenderingContextBase::TextureUnitState);
 
 #endif  // WebGLRenderingContextBase_h