[wrapper-tracing] Add tracing to WebGLRenderingContextBase and friends

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

 // Copyright 2015 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.
 
 #include "modules/webgl/WebGL2RenderingContextBase.h"
 
 #include "bindings/modules/v8/WebGLAny.h"
 #include "core/frame/ImageBitmap.h"
 #include "core/html/HTMLCanvasElement.h"
 #include "core/html/HTMLImageElement.h"
@@ skipping 4243 matching lines @@
   visitor->trace(m_boundTransformFeedbackBuffer);
   visitor->trace(m_boundUniformBuffer);
   visitor->trace(m_boundIndexedTransformFeedbackBuffers);
   visitor->trace(m_boundIndexedUniformBuffers);
   visitor->trace(m_currentBooleanOcclusionQuery);
   visitor->trace(m_currentTransformFeedbackPrimitivesWrittenQuery);
   visitor->trace(m_samplerUnits);
   WebGLRenderingContextBase::trace(visitor);
 }
 
+DEFINE_TRACE_WRAPPERS(WebGL2RenderingContextBase) {

[Ken Russell (switch to Gerrit), 2016/10/06 19:05:14]

It's unfortunate that basically exactly the same code has to be written in
DEFINE_TRACE and DEFINE_TRACE_WRAPPERS. Can you think of a way to use templates
to have one template method that can be instantiated twice, each time with a
different method pointer, and invoke that method pointer against the incoming
visitor argument? If the objects that are traced, and how they're traced, could
be made the same between these two methods, that would make it more feasible.
See below.

[Michael Lippautz, 2016/10/06 19:58:13]

It's exactly the code because all members here (and I think WebGL in general)
are of type ScriptWrappable. In cases where you would have only a few
ScriptWrappable wrapper tracing could be significantly faster than regular
tracing.

Having said that, I totally agree that we should do something about the
duplication (templates, macros,... ). Right now the priorities are on
completeness to get tracing into a state where we can ship.

[Ken Russell (switch to Gerrit), 2016/10/07 03:01:50]

OK -- sounds fine.

[haraken, 2016/10/07 04:48:49]

Yeah, in general, things traced by traceWrapper()s should be much fewer than
things traced by trace()s.

+  if (isContextLost()) {
+    return;
+  }
+
+  visitor->traceWrappers(m_transformFeedbackBinding);
+  visitor->traceWrappers(m_readFramebufferBinding);
+  visitor->traceWrappers(m_boundCopyReadBuffer);
+  visitor->traceWrappers(m_boundCopyWriteBuffer);
+  visitor->traceWrappers(m_boundPixelPackBuffer);
+  visitor->traceWrappers(m_boundPixelUnpackBuffer);
+  visitor->traceWrappers(m_boundTransformFeedbackBuffer);
+  visitor->traceWrappers(m_boundUniformBuffer);
+  for (auto& buf : m_boundIndexedTransformFeedbackBuffers) {
+    visitor->traceWrappers(buf);

[Ken Russell (switch to Gerrit), 2016/10/06 19:05:14]

The tracing of the HeapVectors is different from the Oilpan tracing above in
DEFINE_TRACE. Is the Oilpan version wrong (or is this one)? Do they have to be
different, or could for example a template traceWrappers method be added to
HeapVector which would be present if the target type is ScriptWrappable (or
Member of ScriptWrappable)?

[Michael Lippautz, 2016/10/06 19:58:13]

Regular Oilpan tracing is integrated into HeapVector, i.e., it traces each slot
of the vector. Wrapper tracing still lacks these infrastructure features. So
both a correct :)

+  }
+  for (auto& buf : m_boundIndexedUniformBuffers) {
+    visitor->traceWrappers(buf);
+  }
+  visitor->traceWrappers(m_currentBooleanOcclusionQuery);
+  visitor->traceWrappers(m_currentTransformFeedbackPrimitivesWrittenQuery);
+  for (auto& unit : m_samplerUnits) {
+    visitor->traceWrappers(unit);
+  }
+  WebGLRenderingContextBase::traceWrappers(visitor);
+}
+
 WebGLTexture* WebGL2RenderingContextBase::validateTexture3DBinding(
     const char* functionName,
     GLenum target) {
   WebGLTexture* tex = nullptr;
   switch (target) {
     case GL_TEXTURE_2D_ARRAY:
       tex = m_textureUnits[m_activeTextureUnit].m_texture2DArrayBinding.get();
       break;
     case GL_TEXTURE_3D:
       tex = m_textureUnits[m_activeTextureUnit].m_texture3DBinding.get();
@@ skipping 201 matching lines @@
   params.skipPixels = m_unpackSkipPixels;
   params.skipRows = m_unpackSkipRows;
   if (dimension == Tex3D) {
     params.imageHeight = m_unpackImageHeight;
     params.skipImages = m_unpackSkipImages;
   }
   return params;
 }
 
 }  // namespace blink