[wrapper-tracing] Add tracing to WebGLRenderingContextBase and friends

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

Index: third_party/WebKit/Source/modules/webgl/WebGL2RenderingContextBase.cpp
diff --git a/third_party/WebKit/Source/modules/webgl/WebGL2RenderingContextBase.cpp b/third_party/WebKit/Source/modules/webgl/WebGL2RenderingContextBase.cpp
index 9c976e9cd5d6ef6bf64d3e53cde1613394f8050b..26c3491ea2acc60bafef74ac3cc692d4cab48976 100644
--- a/third_party/WebKit/Source/modules/webgl/WebGL2RenderingContextBase.cpp
+++ b/third_party/WebKit/Source/modules/webgl/WebGL2RenderingContextBase.cpp
@@ -4261,6 +4261,33 @@ DEFINE_TRACE(WebGL2RenderingContextBase) {
   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) {