Make lost context callback a base::Closure thru the WGC3DProvider.

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/NotImplemented.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 "wtf/ArrayBufferContents.h"
+#include "wtf/Functional.h"
 #include "wtf/PassOwnPtr.h"
 #include "wtf/text/StringBuilder.h"
 #include "wtf/text/StringUTF8Adaptor.h"
 
 namespace blink {
 
 namespace {
 
 const double secondsBetweenRestoreAttempts = 1.0;
 const int maxGLErrorsAllowedToConsole = 256;
@@ skipping 374 matching lines @@
 
     ~ScopedFramebufferRestorer()
     {
         m_context->restoreCurrentFramebuffer();
     }
 
 private:
     RawPtrWillBeMember<WebGLRenderingContextBase> m_context;
 };
 
 class WebGLRenderingContextLostCallback final : public GarbageCollectedFinalized<WebGLRenderingContextLostCallback>, public WebGraphicsContext3D::WebGraphicsContextLostCallback {

[Ken Russell (switch to Gerrit), 2016/03/24 18:29:04]

Can this class be removed now?

[danakj, 2016/03/24 18:36:50]

Oh, ya! Thanks

 public:
     static WebGLRenderingContextLostCallback* create(WebGLRenderingContextBase* context)
     {
         return new WebGLRenderingContextLostCallback(context);
     }
 
     ~WebGLRenderingContextLostCallback() override { }
 
     virtual void onContextLost() { m_context->forceLostContext(WebGLRenderingContextBase::RealLostContext, WebGLRenderingContextBase::Auto); }
 
@@ skipping 481 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_contextLostCallbackAdapter = WebGLRenderingContextLostCallback::create(this);
     m_errorMessageCallbackAdapter = WebGLRenderingContextErrorMessageCallback::create(this);
 
-    webContext()->setContextLostCallback(m_contextLostCallbackAdapter.get());
+    // Uses raw |this| as the callback is reset before |this| is destroyed.
+    drawingBuffer()->contextProvider()->setLostContextCallback(WebClosure(WTF::bind(&WebGLRenderingContextBase::forceLostContext, this, WebGLRenderingContextBase::RealLostContext, WebGLRenderingContextBase::Auto)));
     webContext()->setErrorMessageCallback(m_errorMessageCallbackAdapter.get());
 
     // This ensures that the context has a valid "lastFlushID" and won't be mistakenly identified as the "least recently used" context.
     contextGL()->Flush();
 
     for (int i = 0; i < WebGLExtensionNameCount; ++i)
         m_extensionEnabled[i] = false;
 
     m_isWebGL2FormatsTypesAdded = false;
     m_isWebGL2InternalFormatsCopyTexImageAdded = false;
@@ skipping 95 matching lines @@
     willDestroyContext(this);
 }
 
 void WebGLRenderingContextBase::destroyContext()
 {
     if (!drawingBuffer())
         return;
 
     m_extensionsUtil.clear();
 
-    webContext()->setContextLostCallback(nullptr);
+    drawingBuffer()->contextProvider()->setLostContextCallback(WebClosure());
     webContext()->setErrorMessageCallback(nullptr);
 
     ASSERT(drawingBuffer());
     m_drawingBuffer->beginDestruction();
     m_drawingBuffer.clear();
 }
 
 void WebGLRenderingContextBase::markContextChanged(ContentChangeType changeType)
 {
     if (m_framebufferBinding || isContextLost())
@@ skipping 5150 matching lines @@
     visitor->trace(m_textureCubeMapBinding);
     visitor->trace(m_texture3DBinding);
     visitor->trace(m_texture2DArrayBinding);
 }
 
 DEFINE_TRACE(WebGLRenderingContextBase)
 {
 #if ENABLE(OILPAN)
     visitor->trace(m_contextObjects);
 #endif
-    visitor->trace(m_contextLostCallbackAdapter);
     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);
@@ skipping 37 matching lines @@
         contextGL()->PixelStorei(GL_UNPACK_ALIGNMENT, 1);
 }
 
 void WebGLRenderingContextBase::restoreUnpackParameters()
 {
     if (m_unpackAlignment != 1)
         contextGL()->PixelStorei(GL_UNPACK_ALIGNMENT, m_unpackAlignment);
 }
 
 } // namespace blink