Remove setErrorMessageCallback from WebGraphicsContext3D.

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
@@ skipping 78 matching lines @@
 #include "platform/CheckedInt.h"
 #include "platform/RuntimeEnabledFeatures.h"
 #include "platform/geometry/IntSize.h"
 #include "platform/graphics/GraphicsContext.h"
 #include "platform/graphics/UnacceleratedImageBufferSurface.h"
 #include "platform/graphics/gpu/AcceleratedImageBufferSurface.h"
 #include "platform/graphics/gpu/DrawingBuffer.h"
 #include "public/platform/Platform.h"
 #include "public/platform/WebGraphicsContext3D.h"
 #include "public/platform/WebGraphicsContext3DProvider.h"
-#include "public/platform/callback/WebClosure.h"
+#include "public/platform/functional/WebFunction.h"
 #include "wtf/Functional.h"
 #include "wtf/PassOwnPtr.h"
 #include "wtf/text/StringBuilder.h"
 #include "wtf/text/StringUTF8Adaptor.h"
 #include "wtf/typed_arrays/ArrayBufferContents.h"
 
 namespace blink {
 
 namespace {
 
@@ skipping 365 matching lines @@
 
     ~ScopedFramebufferRestorer()
     {
         m_context->restoreCurrentFramebuffer();
     }
 
 private:
     Member<WebGLRenderingContextBase> m_context;
 };
 
-class WebGLRenderingContextErrorMessageCallback final : public GarbageCollectedFinalized<WebGLRenderingContextErrorMessageCallback>, public WebGraphicsContext3D::WebGraphicsErrorMessageCallback {
-public:
-    static WebGLRenderingContextErrorMessageCallback* create(WebGLRenderingContextBase* context)
-    {
-        return new WebGLRenderingContextErrorMessageCallback(context);
-    }
-
-    ~WebGLRenderingContextErrorMessageCallback() override { }
-
-    virtual void onErrorMessage(const WebString& message, GLint)
-    {
-        if (m_context->m_synthesizedErrorsToConsole)
-            m_context->printGLErrorToConsole(message);
-        InspectorInstrumentation::didFireWebGLErrorOrWarning(m_context->canvas(), message);
-    }
-
-    DEFINE_INLINE_TRACE()
-    {
-        visitor->trace(m_context);
-    }
-
-private:
-    explicit WebGLRenderingContextErrorMessageCallback(WebGLRenderingContextBase* context)
-        : m_context(context) { }
-
-    Member<WebGLRenderingContextBase> m_context;
-};
-
 static void formatWebGLStatusString(const String& glInfo, const String& infostring, String& statusMessage)
 {
     if (!infostring.isEmpty())
         statusMessage.append(", " + glInfo + " = " + infostring);
 }
 
 static String extractWebGLContextCreationError(const Platform::GraphicsInfo& info)
 {
     String statusMessage("Could not create a WebGL context");
     formatWebGLStatusString("VENDOR", info.vendorId ? String::format("0x%04x", info.vendorId).utf8().data() : "0xffff", statusMessage);
@@ skipping 433 matching lines @@
     // for the default VAO. (This object is never exposed to JavaScript, but we need to link other
     // JavaScript wrappers to it.)
     m_preservedDefaultVAOObjectWrapper = false;
     m_boundVertexArrayObject = m_defaultVertexArrayObject;
 
     m_vertexAttribType.resize(m_maxVertexAttribs);
 
     contextGL()->Viewport(0, 0, drawingBufferWidth(), drawingBufferHeight());
     contextGL()->Scissor(0, 0, drawingBufferWidth(), drawingBufferHeight());
 
-    m_errorMessageCallbackAdapter = WebGLRenderingContextErrorMessageCallback::create(this);
-
-    drawingBuffer()->contextProvider()->setLostContextCallback(WebClosure(WTF::bind(&WebGLRenderingContextBase::forceLostContext, createWeakThisPointer(), WebGLRenderingContextBase::RealLostContext, WebGLRenderingContextBase::Auto)));
-    webContext()->setErrorMessageCallback(m_errorMessageCallbackAdapter.get());
+    drawingBuffer()->contextProvider()->setLostContextCallback(
+        WebClosure(bind(
+            &WebGLRenderingContextBase::forceLostContext,
+            createWeakThisPointer(),
+            WebGLRenderingContextBase::RealLostContext,
+            WebGLRenderingContextBase::Auto)));
+    drawingBuffer()->contextProvider()->setErrorMessageCallback(
+        WebFunction<void(const char*, int32_t)>(bind<const char*, int32_t>(
+            &WebGLRenderingContextBase::onErrorMessage,
+            createWeakThisPointer())));
 
     // If WebGL 2, the PRIMITIVE_RESTART_FIXED_INDEX should be always enabled.
     // See the section <Primitive Restart is Always Enabled> in WebGL 2 spec:
     // https://www.khronos.org/registry/webgl/specs/latest/2.0/#4.1.4
     if (isWebGL2OrHigher())
         contextGL()->Enable(GL_PRIMITIVE_RESTART_FIXED_INDEX);
 
     // This ensures that the context has a valid "lastFlushID" and won't be mistakenly identified as the "least recently used" context.
     contextGL()->Flush();
 
@@ skipping 88 matching lines @@
 }
 
 void WebGLRenderingContextBase::destroyContext()
 {
     if (!drawingBuffer())
         return;
 
     m_extensionsUtil.clear();
 
     drawingBuffer()->contextProvider()->setLostContextCallback(WebClosure());
-    webContext()->setErrorMessageCallback(nullptr);
+    drawingBuffer()->contextProvider()->setErrorMessageCallback(WebFunction<void(const char*, int32_t)>());
 
     ASSERT(drawingBuffer());
     m_drawingBuffer->beginDestruction();
     m_drawingBuffer.clear();
 }
 
 void WebGLRenderingContextBase::markContextChanged(ContentChangeType changeType)
 {
     if (m_framebufferBinding || isContextLost())
         return;
 
     drawingBuffer()->markContentsChanged();
 
     LayoutBox* layoutBox = canvas()->layoutBox();
     if (layoutBox && layoutBox->hasAcceleratedCompositing()) {
         m_markedCanvasDirty = true;
         canvas()->clearCopiedImage();
         layoutBox->contentChanged(changeType);
     } else {
         if (!m_markedCanvasDirty) {
             m_markedCanvasDirty = true;
             canvas()->didDraw(FloatRect(FloatPoint(0, 0), FloatSize(clampedCanvasSize())));
         }
     }
 }
 
+void WebGLRenderingContextBase::onErrorMessage(const char* message, int32_t id)
+{
+    if (m_synthesizedErrorsToConsole)
+        printGLErrorToConsole(message);
+    InspectorInstrumentation::didFireWebGLErrorOrWarning(canvas(), message);
+}
+
 void WebGLRenderingContextBase::notifyCanvasContextChanged()
 {
     if (!canvas())
         return;
 
     canvas()->notifyListenersCanvasChanged();
 }
 
 WebGLRenderingContextBase::HowToClear WebGLRenderingContextBase::clearIfComposited(GLbitfield mask)
 {
@@ skipping 5134 matching lines @@
 {
     visitor->trace(m_texture2DBinding);
     visitor->trace(m_textureCubeMapBinding);
     visitor->trace(m_texture3DBinding);
     visitor->trace(m_texture2DArrayBinding);
 }
 
 DEFINE_TRACE(WebGLRenderingContextBase)
 {
     visitor->trace(m_contextObjects);
-    visitor->trace(m_errorMessageCallbackAdapter);
     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_valuebufferBinding);
     visitor->trace(m_textureUnits);
     visitor->trace(m_extensions);
     CanvasRenderingContext::trace(visitor);
@@ skipping 36 matching lines @@
         contextGL()->PixelStorei(GL_UNPACK_ALIGNMENT, 1);
 }
 
 void WebGLRenderingContextBase::restoreUnpackParameters()
 {
     if (m_unpackAlignment != 1)
         contextGL()->PixelStorei(GL_UNPACK_ALIGNMENT, m_unpackAlignment);
 }
 
 } // namespace blink