Remove WebGLObject maps from WebGLRenderingContextBase and WebGLContextGroup.

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 219 matching lines @@
     WebGLRenderingContextBase* context) {
   static int generation = 0;
   forciblyEvictedContexts().set(context, generation++);
 }
 
 void WebGLRenderingContextBase::removeFromEvictedList(
     WebGLRenderingContextBase* context) {
   forciblyEvictedContexts().remove(context);
 }
 
-void WebGLRenderingContextBase::willDestroyContext(
+void WebGLRenderingContextBase::restoreEvictedContext(
     WebGLRenderingContextBase* context) {
   // These two sets keep weak references to their contexts;
   // verify that the GC already removed the |context| entries.
   ASSERT(!forciblyEvictedContexts().contains(context));
   ASSERT(!activeContexts().contains(context));
 
   unsigned maxGLContexts = currentMaxGLContexts();
   // Try to re-enable the oldest inactive contexts.
   while (activeContexts().size() < maxGLContexts &&
          forciblyEvictedContexts().size()) {
@@ skipping 740 matching lines @@
 
 WebGLRenderingContextBase::WebGLRenderingContextBase(
     HTMLCanvasElement* passedCanvas,
     OffscreenCanvas* passedOffscreenCanvas,
     std::unique_ptr<WebGraphicsContext3DProvider> contextProvider,
     const CanvasContextCreationAttributes& requestedAttributes,
     unsigned version)
     : CanvasRenderingContext(passedCanvas,
                              passedOffscreenCanvas,
                              requestedAttributes),
+      m_contextGroup(this, new WebGLContextGroup()),
       m_isHidden(false),
       m_contextLostMode(NotLostContext),
       m_autoRecoveryMethod(Manual),
       m_dispatchContextLostEventTimer(
           this,
           &WebGLRenderingContextBase::dispatchContextLostEvent),
       m_restoreAllowed(false),
       m_restoreTimer(this, &WebGLRenderingContextBase::maybeRestoreContext),
       m_boundArrayBuffer(this, nullptr),
       m_boundVertexArrayObject(this, nullptr),
       m_currentProgram(this, nullptr),
       m_framebufferBinding(this, nullptr),
       m_renderbufferBinding(this, nullptr),
       m_generatedImageCache(4),
       m_synthesizedErrorsToConsole(true),
       m_numGLErrorsToConsoleAllowed(maxGLErrorsAllowedToConsole),
       m_onePlusMaxNonDefaultTextureUnit(0),
       m_isWebGL2FormatsTypesAdded(false),
       m_isWebGL2TexImageSourceFormatsTypesAdded(false),
       m_isWebGL2InternalFormatsCopyTexImageAdded(false),
       m_isOESTextureFloatFormatsTypesAdded(false),
       m_isOESTextureHalfFloatFormatsTypesAdded(false),
       m_isWebGLDepthTextureFormatsTypesAdded(false),
       m_isEXTsRGBFormatsTypesAdded(false),
       m_version(version) {
   ASSERT(contextProvider);
 
-  m_contextGroup = WebGLContextGroup::create();
   m_contextGroup->addContext(this);
 
   m_maxViewportDims[0] = m_maxViewportDims[1] = 0;
   contextProvider->contextGL()->GetIntegerv(GL_MAX_VIEWPORT_DIMS,
                                             m_maxViewportDims);
 
   RefPtr<DrawingBuffer> buffer;
   // On Mac OS, DrawingBuffer is using an IOSurface as its backing storage, this
   // allows WebGL-rendered canvases to be composited by the OS rather than
   // Chrome.
@@ skipping 127 matching lines @@
   // These two values from EXT_draw_buffers are lazily queried.
   m_maxDrawBuffers = 0;
   m_maxColorAttachments = 0;
 
   m_backDrawBuffer = GL_BACK;
 
   m_readBufferOfDefaultFramebuffer = GL_BACK;
 
   m_defaultVertexArrayObject = WebGLVertexArrayObject::create(
       this, WebGLVertexArrayObjectBase::VaoTypeDefault);
-  addContextObject(m_defaultVertexArrayObject.get());
 
   m_boundVertexArrayObject = m_defaultVertexArrayObject;
 
   m_vertexAttribType.resize(m_maxVertexAttribs);
 
   contextGL()->Viewport(0, 0, drawingBufferWidth(), drawingBufferHeight());
   m_scissorBox[0] = m_scissorBox[1] = 0;
   m_scissorBox[2] = drawingBufferWidth();
   m_scissorBox[3] = drawingBufferHeight();
   contextGL()->Scissor(m_scissorBox[0], m_scissorBox[1], m_scissorBox[2],
@@ skipping 78 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() {
-  // 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_currentProgram = nullptr;
-  m_framebufferBinding = nullptr;
-  m_renderbufferBinding = nullptr;
-
-  // WebGLTexture shared objects will be detached and deleted
-  // m_contextGroup->removeContext(this), which will bring about deleteTexture()
-  // calls.  We null these out to avoid accessing those members in
-  // deleteTexture().
-  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;
-  }
-
-  detachAndRemoveAllObjects();
-
-  // Release all extensions now.
-  for (ExtensionTracker* tracker : m_extensions) {
-    tracker->loseExtension(true);
-  }
-  m_extensions.clear();
-
-  // Context must be removed from the group prior to the destruction of the
-  // GL context, otherwise shared objects may not be properly deleted.
-  m_contextGroup->removeContext(this);
-
+  // Now that the context and context group no longer hold on to the
+  // objects they create, and now that the objects are eagerly finalized
+  // rather than the context, there is very little useful work that this
+  // destructor can do, since it's not allowed to touch other on-heap
+  // objects. All it can do is destroy its underlying context, which, if
+  // there are no other contexts in the same share group, will cause all of
+  // the underlying graphics resources to be deleted. (Currently, it's
+  // always the case that there are no other contexts in the same share
+  // group -- resource sharing between WebGL contexts is not yet
+  // implemented, and due to its complex semantics, it's doubtful that it
+  // ever will be.)
   destroyContext();
 
-  willDestroyContext(this);
+  // Now that this context is destroyed, see if there's a
+  // previously-evicted one that should be restored.
+  restoreEvictedContext(this);
 }
 
 void WebGLRenderingContextBase::destroyContext() {
   if (!drawingBuffer())
     return;
 
   m_extensionsUtil.reset();
 
   std::unique_ptr<WTF::Closure> nullClosure;
   std::unique_ptr<WTF::Function<void(const char*, int32_t)>> nullFunction;
@@ skipping 828 matching lines @@
     return;
   clearIfComposited();
   ScopedDrawingBufferBinder binder(drawingBuffer(), readFramebufferBinding);
   contextGL()->CopyTexSubImage2D(target, level, xoffset, yoffset, x, y, width,
                                  height);
 }
 
 WebGLBuffer* WebGLRenderingContextBase::createBuffer() {
   if (isContextLost())
     return nullptr;
-  WebGLBuffer* o = WebGLBuffer::create(this);
-  addSharedObject(o);
-  return o;
+  return WebGLBuffer::create(this);
 }
 
 WebGLFramebuffer* WebGLRenderingContextBase::createFramebuffer() {
   if (isContextLost())
     return nullptr;
-  WebGLFramebuffer* o = WebGLFramebuffer::create(this);
-  addContextObject(o);
-  return o;
+  return WebGLFramebuffer::create(this);
 }
 
 WebGLTexture* WebGLRenderingContextBase::createTexture() {
   if (isContextLost())
     return nullptr;
-  WebGLTexture* o = WebGLTexture::create(this);
-  addSharedObject(o);
-  return o;
+  return WebGLTexture::create(this);
 }
 
 WebGLProgram* WebGLRenderingContextBase::createProgram() {
   if (isContextLost())
     return nullptr;
-  WebGLProgram* o = WebGLProgram::create(this);
-  addSharedObject(o);
-  return o;
+  return WebGLProgram::create(this);
 }
 
 WebGLRenderbuffer* WebGLRenderingContextBase::createRenderbuffer() {
   if (isContextLost())
     return nullptr;
-  WebGLRenderbuffer* o = WebGLRenderbuffer::create(this);
-  addSharedObject(o);
-  return o;
+  return WebGLRenderbuffer::create(this);
 }
 
 void WebGLRenderingContextBase::setBoundVertexArrayObject(
     WebGLVertexArrayObjectBase* arrayObject) {
   if (arrayObject)
     m_boundVertexArrayObject = arrayObject;
   else
     m_boundVertexArrayObject = m_defaultVertexArrayObject;
 }
 
 WebGLShader* WebGLRenderingContextBase::createShader(GLenum type) {
   if (isContextLost())
     return nullptr;
   if (type != GL_VERTEX_SHADER && type != GL_FRAGMENT_SHADER) {
     synthesizeGLError(GL_INVALID_ENUM, "createShader", "invalid shader type");
     return nullptr;
   }
 
-  WebGLShader* o = WebGLShader::create(this, type);
-  addSharedObject(o);
-  return o;
+  return WebGLShader::create(this, type);
 }
 
 void WebGLRenderingContextBase::cullFace(GLenum mode) {
   if (isContextLost())
     return;
   contextGL()->CullFace(mode);
 }
 
 bool WebGLRenderingContextBase::deleteObject(WebGLObject* object) {
   if (isContextLost() || !object)
@@ skipping 3888 matching lines @@
 void WebGLRenderingContextBase::loseContextImpl(
     WebGLRenderingContextBase::LostContextMode mode,
     AutoRecoveryMethod autoRecoveryMethod) {
   if (isContextLost())
     return;
 
   m_contextLostMode = mode;
   ASSERT(m_contextLostMode != NotLostContext);
   m_autoRecoveryMethod = autoRecoveryMethod;
 
-  detachAndRemoveAllObjects();
-
   // Lose all the extensions.
   for (size_t i = 0; i < m_extensions.size(); ++i) {
     ExtensionTracker* tracker = m_extensions[i];
     tracker->loseExtension(false);
   }
 
   for (size_t i = 0; i < WebGLExtensionNameCount; ++i)
     m_extensionEnabled[i] = false;
 
   removeAllCompressedTextureFormats();
@@ skipping 29 matching lines @@
     if (m_contextLostMode == WebGLLoseContextLostContext)
       synthesizeGLError(GL_INVALID_OPERATION, "restoreContext",
                         "context restoration not allowed");
     return;
   }
 
   if (!m_restoreTimer.isActive())
     m_restoreTimer.startOneShot(0, BLINK_FROM_HERE);
 }
 
+uint32_t WebGLRenderingContextBase::numberOfContextLosses() const {
+  return m_contextGroup->numberOfContextLosses();
+}
+
 WebLayer* WebGLRenderingContextBase::platformLayer() const {
   return isContextLost() ? 0 : drawingBuffer()->platformLayer();
 }
 
 void WebGLRenderingContextBase::setFilterQuality(
     SkFilterQuality filterQuality) {
   if (!isContextLost() && drawingBuffer()) {
     drawingBuffer()->setFilterQuality(filterQuality);
   }
 }
 
 Extensions3DUtil* WebGLRenderingContextBase::extensionsUtil() {
   if (!m_extensionsUtil) {
     gpu::gles2::GLES2Interface* gl = contextGL();
     m_extensionsUtil = Extensions3DUtil::create(gl);
     // The only reason the ExtensionsUtil should be invalid is if the gl context
     // is lost.
     ASSERT(m_extensionsUtil->isValid() ||
            gl->GetGraphicsResetStatusKHR() != GL_NO_ERROR);
   }
   return m_extensionsUtil.get();
 }
 
-void WebGLRenderingContextBase::removeSharedObject(WebGLSharedObject* object) {
-  m_contextGroup->removeObject(object);
-}
-
-void WebGLRenderingContextBase::addSharedObject(WebGLSharedObject* object) {
-  ASSERT(!isContextLost());
-  m_contextGroup->addObject(object);
-}
-
-void WebGLRenderingContextBase::removeContextObject(
-    WebGLContextObject* object) {
-  m_contextObjects.remove(object);
-}
-
 void WebGLRenderingContextBase::visitChildDOMWrappers(
     v8::Isolate* isolate,
     const v8::Persistent<v8::Object>& wrapper) {
   if (isContextLost()) {
     return;
   }
   DOMWrapperWorld::setWrapperReferencesInAllWorlds(wrapper, m_boundArrayBuffer,
                                                    isolate);
   DOMWrapperWorld::setWrapperReferencesInAllWorlds(
       wrapper, m_renderbufferBinding, isolate);
@@ skipping 27 matching lines @@
     m_boundVertexArrayObject->visitChildDOMWrappers(isolate, wrapper);
   }
 
   for (ExtensionTracker* tracker : m_extensions) {
     WebGLExtension* extension = tracker->getExtensionObjectIfAlreadyEnabled();
     DOMWrapperWorld::setWrapperReferencesInAllWorlds(wrapper, extension,
                                                      isolate);
   }
 }
 
-void WebGLRenderingContextBase::addContextObject(WebGLContextObject* object) {
-  ASSERT(!isContextLost());
-  m_contextObjects.add(object);
-}
-
-void WebGLRenderingContextBase::detachAndRemoveAllObjects() {
-  while (m_contextObjects.size() > 0) {
-    // Following detachContext() will remove the iterated object from
-    // |m_contextObjects|, and thus we need to look up begin() every time.
-    auto it = m_contextObjects.begin();
-    (*it)->detachContext();
-  }
-}
-
 void WebGLRenderingContextBase::stop() {
   if (!isContextLost()) {
     // Never attempt to restore the context because the page is being torn down.
     forceLostContext(SyntheticLostContext, Manual);
   }
 }
 
 bool WebGLRenderingContextBase::DrawingBufferClientIsBoundForDraw() {
   return !m_framebufferBinding;
 }
@@ skipping 1397 matching lines @@
 }
 
 DEFINE_TRACE(WebGLRenderingContextBase::TextureUnitState) {
   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_contextGroup);
   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_textureUnits);
   visitor->trace(m_extensions);
   CanvasRenderingContext::trace(visitor);
 }
@@ skipping 67 matching lines @@
 
 void WebGLRenderingContextBase::getHTMLOrOffscreenCanvas(
     HTMLCanvasElementOrOffscreenCanvas& result) const {
   if (canvas())
     result.setHTMLCanvasElement(canvas());
   else
     result.setOffscreenCanvas(getOffscreenCanvas());
 }
 
 }  // namespace blink