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

third_party/WebKit/Source/modules/webgl/WebGLRenderingContextBase.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
  *    documentation and/or other materials provided with the distribution.
  *
  * THIS SOFTWARE IS PROVIDED BY APPLE COMPUTER, INC. ``AS IS'' AND ANY
  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE COMPUTER, INC. OR
  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #include "modules/webgl/WebGLRenderingContextBase.h"
 
 #include "bindings/core/v8/ExceptionMessages.h"
 #include "bindings/core/v8/ExceptionState.h"
+#include "bindings/core/v8/ScriptWrappableVisitor.h"
 #include "bindings/core/v8/V8BindingMacros.h"
 #include "bindings/modules/v8/HTMLCanvasElementOrOffscreenCanvas.h"
 #include "bindings/modules/v8/WebGLAny.h"
 #include "core/dom/DOMArrayBuffer.h"
 #include "core/dom/DOMTypedArray.h"
 #include "core/dom/FlexibleArrayBufferView.h"
 #include "core/fetch/ImageResource.h"
 #include "core/frame/ImageBitmap.h"
 #include "core/frame/LocalFrame.h"
 #include "core/frame/Settings.h"
@@ skipping 932 matching lines @@
                              passedOffscreenCanvas,
                              requestedAttributes),
       m_isHidden(false),
       m_contextLostMode(NotLostContext),
       m_autoRecoveryMethod(Manual),
       m_dispatchContextLostEventTimer(
           this,
           &WebGLRenderingContextBase::dispatchContextLostEvent),
       m_restoreAllowed(false),
       m_restoreTimer(this, &WebGLRenderingContextBase::maybeRestoreContext),
+      m_boundArrayBuffer(this, nullptr),
+      m_boundVertexArrayObject(this, nullptr),
+      m_currentProgram(this, nullptr),
+      m_framebufferBinding(this, nullptr),
+      m_renderbufferBinding(this, nullptr),
       m_generatedImageCache(4),
       m_synthesizedErrorsToConsole(true),
       m_numGLErrorsToConsoleAllowed(maxGLErrorsAllowedToConsole),
       m_onePlusMaxNonDefaultTextureUnit(0),
       m_isWebGL2FormatsTypesAdded(false),
       m_isWebGL2TexImageSourceFormatsTypesAdded(false),
       m_isWebGL2InternalFormatsCopyTexImageAdded(false),
       m_isOESTextureFloatFormatsTypesAdded(false),
       m_isOESTextureHalfFloatFormatsTypesAdded(false),
       m_isWebGLDepthTextureFormatsTypesAdded(false),
@@ skipping 756 matching lines @@
                       "attempt to bind a deleted texture");
     return;
   }
   if (texture && texture->getTarget() && texture->getTarget() != target) {
     synthesizeGLError(GL_INVALID_OPERATION, "bindTexture",
                       "textures can not be used with multiple targets");
     return;
   }
 
   if (target == GL_TEXTURE_2D) {
-    m_textureUnits[m_activeTextureUnit].m_texture2DBinding = texture;
+    m_textureUnits[m_activeTextureUnit].m_texture2DBinding =
+        TraceWrapperMember<WebGLTexture>(this, texture);
 
     if (!m_activeTextureUnit)
       drawingBuffer()->setTexture2DBinding(objectOrZero(texture));
   } else if (target == GL_TEXTURE_CUBE_MAP) {
-    m_textureUnits[m_activeTextureUnit].m_textureCubeMapBinding = texture;
+    m_textureUnits[m_activeTextureUnit].m_textureCubeMapBinding =
+        TraceWrapperMember<WebGLTexture>(this, texture);
   } else if (isWebGL2OrHigher() && target == GL_TEXTURE_2D_ARRAY) {
-    m_textureUnits[m_activeTextureUnit].m_texture2DArrayBinding = texture;
+    m_textureUnits[m_activeTextureUnit].m_texture2DArrayBinding =
+        TraceWrapperMember<WebGLTexture>(this, texture);
   } else if (isWebGL2OrHigher() && target == GL_TEXTURE_3D) {
-    m_textureUnits[m_activeTextureUnit].m_texture3DBinding = texture;
+    m_textureUnits[m_activeTextureUnit].m_texture3DBinding =
+        TraceWrapperMember<WebGLTexture>(this, texture);
   } else {
     synthesizeGLError(GL_INVALID_ENUM, "bindTexture", "invalid target");
     return;
   }
 
   contextGL()->BindTexture(target, objectOrZero(texture));
   if (texture) {
     texture->setTarget(target);
     m_onePlusMaxNonDefaultTextureUnit =
         max(m_activeTextureUnit + 1, m_onePlusMaxNonDefaultTextureUnit);
@@ skipping 5666 matching lines @@
   m_onePlusMaxNonDefaultTextureUnit = 0;
 }
 
 DEFINE_TRACE(WebGLRenderingContextBase::TextureUnitState) {
   visitor->trace(m_texture2DBinding);
   visitor->trace(m_textureCubeMapBinding);
   visitor->trace(m_texture3DBinding);
   visitor->trace(m_texture2DArrayBinding);
 }
 
+DEFINE_TRACE_WRAPPERS(WebGLRenderingContextBase::TextureUnitState) {
+  visitor->traceWrappers(m_texture2DBinding);
+  visitor->traceWrappers(m_textureCubeMapBinding);
+  visitor->traceWrappers(m_texture3DBinding);
+  visitor->traceWrappers(m_texture2DArrayBinding);
+}
+
 DEFINE_TRACE(WebGLRenderingContextBase) {
   visitor->trace(m_contextObjects);
   visitor->trace(m_boundArrayBuffer);
   visitor->trace(m_defaultVertexArrayObject);
   visitor->trace(m_boundVertexArrayObject);
   visitor->trace(m_currentProgram);
   visitor->trace(m_framebufferBinding);
   visitor->trace(m_renderbufferBinding);
   visitor->trace(m_textureUnits);
   visitor->trace(m_extensions);
   CanvasRenderingContext::trace(visitor);
 }
 
 DEFINE_TRACE_WRAPPERS(WebGLRenderingContextBase) {
   if (isContextLost()) {
     return;
   }
   visitor->traceWrappers(m_boundArrayBuffer);
   visitor->traceWrappers(m_renderbufferBinding);
   visitor->traceWrappers(m_framebufferBinding);
   visitor->traceWrappers(m_currentProgram);
   visitor->traceWrappers(m_boundVertexArrayObject);
   for (auto& unit : m_textureUnits) {
-    visitor->traceWrappers(unit.m_texture2DBinding);
-    visitor->traceWrappers(unit.m_textureCubeMapBinding);
-    visitor->traceWrappers(unit.m_texture3DBinding);
-    visitor->traceWrappers(unit.m_texture2DArrayBinding);
+    visitor->traceWrappers(&unit);
   }
   for (ExtensionTracker* tracker : m_extensions) {
     WebGLExtension* extension = tracker->getExtensionObjectIfAlreadyEnabled();
     visitor->traceWrappers(extension);
   }
   CanvasRenderingContext::traceWrappers(visitor);
 }
 
 int WebGLRenderingContextBase::externallyAllocatedBytesPerPixel() {
   if (isContextLost())
@@ skipping 40 matching lines @@
 
 void WebGLRenderingContextBase::getHTMLOrOffscreenCanvas(
     HTMLCanvasElementOrOffscreenCanvas& result) const {
   if (canvas())
     result.setHTMLCanvasElement(canvas());
   else
     result.setOffscreenCanvas(getOffscreenCanvas());
 }
 
 }  // namespace blink