Oilpan: eagerly finalize WebGLRenderingContext objects.

Source/core/html/canvas/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 55 matching lines @@
 #include "core/html/canvas/WebGLDebugRendererInfo.h"
 #include "core/html/canvas/WebGLDebugShaders.h"
 #include "core/html/canvas/WebGLDepthTexture.h"
 #include "core/html/canvas/WebGLDrawBuffers.h"
 #include "core/html/canvas/WebGLFramebuffer.h"
 #include "core/html/canvas/WebGLLoseContext.h"
 #include "core/html/canvas/WebGLProgram.h"
 #include "core/html/canvas/WebGLRenderbuffer.h"
 #include "core/html/canvas/WebGLShader.h"
 #include "core/html/canvas/WebGLShaderPrecisionFormat.h"
-#include "core/html/canvas/WebGLSharedWebGraphicsContext3D.h"
 #include "core/html/canvas/WebGLTexture.h"
 #include "core/html/canvas/WebGLUniformLocation.h"
 #include "core/html/canvas/WebGLVertexArrayObject.h"
 #include "core/html/canvas/WebGLVertexArrayObjectOES.h"
 #include "core/inspector/ConsoleMessage.h"
 #include "core/inspector/InspectorInstrumentation.h"
 #include "core/layout/LayoutBox.h"
 #include "core/loader/FrameLoader.h"
 #include "core/loader/FrameLoaderClient.h"
 #include "platform/CheckedInt.h"
@@ skipping 556 matching lines @@
 
     m_maxViewportDims[0] = m_maxViewportDims[1] = 0;
     context->getIntegerv(GL_MAX_VIEWPORT_DIMS, m_maxViewportDims);
 
     RefPtr<DrawingBuffer> buffer = createDrawingBuffer(context);
     if (!buffer) {
         m_contextLostMode = SyntheticLostContext;
         return;
     }
 
-#if ENABLE(OILPAN)
-    m_sharedWebGraphicsContext3D = WebGLSharedWebGraphicsContext3D::create(buffer.release());
-#else
     m_drawingBuffer = buffer.release();
-#endif
 
     drawingBuffer()->bind();
     setupFlags();
 }
 
 PassRefPtr<DrawingBuffer> WebGLRenderingContextBase::createDrawingBuffer(PassOwnPtr<WebGraphicsContext3D> context)
 {
     WebGraphicsContext3D::Attributes attrs;
     attrs.alpha = m_requestedAttributes.alpha();
     attrs.depth = m_requestedAttributes.depth();
@@ skipping 121 matching lines @@
 // Helper function for V8 bindings to identify what version of WebGL a CanvasRenderingContext supports.
 unsigned WebGLRenderingContextBase::getWebGLVersion(const CanvasRenderingContext* context)
 {
     if (!context->is3d())
         return 0;
     return static_cast<const WebGLRenderingContextBase*>(context)->version();
 }
 
 WebGLRenderingContextBase::~WebGLRenderingContextBase()
 {
-#if !ENABLE(OILPAN)
     // Remove all references to WebGLObjects so if they are the last reference
     // they will be freed before the last context is removed from the context group.
     m_boundArrayBuffer = nullptr;
     m_defaultVertexArrayObject = nullptr;
     m_boundVertexArrayObject = nullptr;
     m_vertexAttrib0Buffer = nullptr;
     m_currentProgram = nullptr;
     m_framebufferBinding = nullptr;
     m_renderbufferBinding = nullptr;
     m_valuebufferBinding = nullptr;
 
     for (size_t i = 0; i < m_textureUnits.size(); ++i) {
         m_textureUnits[i].m_texture2DBinding = nullptr;
         m_textureUnits[i].m_textureCubeMapBinding = nullptr;
         m_textureUnits[i].m_texture3DBinding = nullptr;
         m_textureUnits[i].m_texture2DArrayBinding = nullptr;
     }
 
     m_blackTexture2D = nullptr;
     m_blackTextureCubeMap = nullptr;
 
     detachAndRemoveAllObjects();
 
     // Release all extensions now.
     m_extensions.clear();
-#endif
 
     // Context must be removed from the group prior to the destruction of the
     // WebGraphicsContext3D, otherwise shared objects may not be properly deleted.
     m_contextGroup->removeContext(this);
 
     destroyContext();
 
-#if !ENABLE(OILPAN)
     if (m_multisamplingObserverRegistered)
         if (Page* page = canvas()->document().page())
             page->removeMultisamplingChangedObserver(this);
-#endif
 
     willDestroyContext(this);
 }
 
 void WebGLRenderingContextBase::destroyContext()
 {
     if (!drawingBuffer())
         return;
 
     m_extensionsUtil.clear();
 
     webContext()->setContextLostCallback(nullptr);
     webContext()->setErrorMessageCallback(nullptr);
 
     ASSERT(drawingBuffer());
-#if ENABLE(OILPAN)
-    // The DrawingBuffer ref pointers are cleared, but the
-    // WebGLSharedWebGraphicsContext3D object will hold onto the
-    // DrawingBuffer for as long as needed (== until all
-    // context objects have been finalized), at which point
-    // DrawingBuffer destruction happens.
-    m_sharedWebGraphicsContext3D.clear();
-#else
     m_drawingBuffer->beginDestruction();
     m_drawingBuffer.clear();
-#endif
 }
 
 void WebGLRenderingContextBase::markContextChanged(ContentChangeType changeType)
 {
     if (m_framebufferBinding || isContextLost())
         return;
 
     drawingBuffer()->markContentsChanged();
 
     LayoutBox* layoutBox = canvas()->layoutBox();
@@ skipping 5055 matching lines @@
     if (!frame)
         return;
 
     Settings* settings = frame->settings();
 
     if (!frame->loader().client()->allowWebGL(settings && settings->webGLEnabled()))
         return;
 
     // If the context was lost due to RealLostContext, we need to destroy the old DrawingBuffer before creating new DrawingBuffer to ensure resource budget enough.
     if (drawingBuffer()) {
-#if ENABLE(OILPAN)
-        m_sharedWebGraphicsContext3D->dispose();
-#else
         m_drawingBuffer->beginDestruction();
         m_drawingBuffer.clear();
-#endif
     }
 
     WebGraphicsContext3D::Attributes attributes = toWebGraphicsContext3DAttributes(m_requestedAttributes, canvas()->document().topDocument().url().string(), settings, version());
     OwnPtr<WebGraphicsContext3D> context = adoptPtr(Platform::current()->createOffscreenGraphicsContext3D(attributes, 0));
     RefPtr<DrawingBuffer> buffer;
     if (context) {
         // Construct a new drawing buffer with the new WebGraphicsContext3D.
         buffer = createDrawingBuffer(context.release());
         // If DrawingBuffer::create() fails to allocate a fbo, |drawingBuffer| is set to null.
     }
     if (!buffer) {
         if (m_contextLostMode == RealLostContext) {
             m_restoreTimer.startOneShot(secondsBetweenRestoreAttempts, FROM_HERE);
         } else {
             // This likely shouldn't happen but is the best way to report it to the WebGL app.
             synthesizeGLError(GL_INVALID_OPERATION, "", "error restoring context");
         }
         return;
     }
 
-#if ENABLE(OILPAN)
-    if (m_sharedWebGraphicsContext3D)
-        m_sharedWebGraphicsContext3D->update(buffer.release());
-    else
-        m_sharedWebGraphicsContext3D = WebGLSharedWebGraphicsContext3D::create(buffer.release());
-#else
     m_drawingBuffer = buffer.release();
-#endif
 
     drawingBuffer()->bind();
     m_lostContextErrors.clear();
     m_contextLostMode = NotLostContext;
     m_autoRecoveryMethod = Manual;
     m_restoreAllowed = false;
     removeFromEvictedList(this);
 
     setupFlags();
     initializeNewContext();
@@ skipping 251 matching lines @@
                 totalBytesPerPixel += samples * bytesPerPixel; // depth/stencil multisample buffer
             totalBytesPerPixel += samples * bytesPerPixel; // color multisample buffer
         } else if (attribs.get().depth() || attribs.get().stencil()) {
             totalBytesPerPixel += bytesPerPixel; // regular depth/stencil buffer
         }
     }
 
     return totalBytesPerPixel;
 }
 
-#if ENABLE(OILPAN)
-PassRefPtr<WebGLSharedWebGraphicsContext3D> WebGLRenderingContextBase::sharedWebGraphicsContext3D() const
-{
-    return m_sharedWebGraphicsContext3D;
-}
-
 DrawingBuffer* WebGLRenderingContextBase::drawingBuffer() const
 {
-    return m_sharedWebGraphicsContext3D ? m_sharedWebGraphicsContext3D->drawingBuffer() : 0;
-}
-#else
-DrawingBuffer* WebGLRenderingContextBase::drawingBuffer() const
-{
     return m_drawingBuffer.get();
 }
-#endif
 
 } // namespace blink