Remove WebGLObject maps from WebGLRenderingContextBase and WebGLContextGroup.

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

 // Copyright 2015 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "modules/webgl/WebGL2RenderingContextBase.h"
 
 #include "bindings/modules/v8/WebGLAny.h"
 #include "core/dom/DOMException.h"
 #include "core/frame/ImageBitmap.h"
 #include "core/html/HTMLCanvasElement.h"
@@ skipping 254 matching lines @@
       m_boundUniformBuffer(this, nullptr),
       m_currentBooleanOcclusionQuery(this, nullptr),
       m_currentTransformFeedbackPrimitivesWrittenQuery(this, nullptr),
       m_currentElapsedQuery(this, nullptr) {
   m_supportedInternalFormatsStorage.insert(
       kSupportedInternalFormatsStorage,
       kSupportedInternalFormatsStorage +
           WTF_ARRAY_LENGTH(kSupportedInternalFormatsStorage));
 }
 
-WebGL2RenderingContextBase::~WebGL2RenderingContextBase() {
-  m_readFramebufferBinding = nullptr;
-
-  m_boundCopyReadBuffer = nullptr;
-  m_boundCopyWriteBuffer = nullptr;
-  m_boundPixelPackBuffer = nullptr;
-  m_boundPixelUnpackBuffer = nullptr;
-  m_boundTransformFeedbackBuffer = nullptr;
-  m_boundUniformBuffer = nullptr;
-
-  m_currentBooleanOcclusionQuery = nullptr;
-  m_currentTransformFeedbackPrimitivesWrittenQuery = nullptr;
-  m_currentElapsedQuery = nullptr;
-}
-
 void WebGL2RenderingContextBase::destroyContext() {
   for (auto& callback : m_getBufferSubDataAsyncCallbacks) {
     callback->destroy();
   }
   m_getBufferSubDataAsyncCallbacks.clear();
 
   WebGLRenderingContextBase::destroyContext();
 }
 
 void WebGL2RenderingContextBase::initializeNewContext() {
@@ skipping 2485 matching lines @@
                                                GLint stencil) {
   if (isContextLost())
     return;
 
   contextGL()->ClearBufferfi(buffer, drawbuffer, depth, stencil);
 }
 
 WebGLQuery* WebGL2RenderingContextBase::createQuery() {
   if (isContextLost())
     return nullptr;
-  WebGLQuery* o = WebGLQuery::create(this);
-  addSharedObject(o);
-  return o;
+  return WebGLQuery::create(this);
 }
 
 void WebGL2RenderingContextBase::deleteQuery(WebGLQuery* query) {
   if (isContextLost() || !query)
     return;
 
   if (m_currentBooleanOcclusionQuery == query) {
     contextGL()->EndQueryEXT(m_currentBooleanOcclusionQuery->getTarget());
     m_currentBooleanOcclusionQuery = nullptr;
   }
@@ skipping 217 matching lines @@
     default:
       synthesizeGLError(GL_INVALID_ENUM, "getQueryParameter",
                         "invalid parameter name");
       return ScriptValue::createNull(scriptState);
   }
 }
 
 WebGLSampler* WebGL2RenderingContextBase::createSampler() {
   if (isContextLost())
     return nullptr;
-  WebGLSampler* o = WebGLSampler::create(this);
-  addSharedObject(o);
-  return o;
+  return WebGLSampler::create(this);
 }
 
 void WebGL2RenderingContextBase::deleteSampler(WebGLSampler* sampler) {
   if (isContextLost())
     return;
 
   for (size_t i = 0; i < m_samplerUnits.size(); ++i) {
     if (sampler == m_samplerUnits[i]) {
       m_samplerUnits[i] = nullptr;
       contextGL()->BindSampler(i, 0);
@@ skipping 171 matching lines @@
                         "invalid parameter name");
       return ScriptValue::createNull(scriptState);
   }
 }
 
 WebGLSync* WebGL2RenderingContextBase::fenceSync(GLenum condition,
                                                  GLbitfield flags) {
   if (isContextLost())
     return nullptr;
 
-  WebGLSync* o = WebGLFenceSync::create(this, condition, flags);
-  addSharedObject(o);
-  return o;
+  return WebGLFenceSync::create(this, condition, flags);
 }
 
 GLboolean WebGL2RenderingContextBase::isSync(WebGLSync* sync) {
   if (isContextLost() || !sync)
     return 0;
 
   return contextGL()->IsSync(sync->object());
 }
 
 void WebGL2RenderingContextBase::deleteSync(WebGLSync* sync) {
@@ skipping 54 matching lines @@
     default:
       synthesizeGLError(GL_INVALID_ENUM, "getSyncParameter",
                         "invalid parameter name");
       return ScriptValue::createNull(scriptState);
   }
 }
 
 WebGLTransformFeedback* WebGL2RenderingContextBase::createTransformFeedback() {
   if (isContextLost())
     return nullptr;
-  WebGLTransformFeedback* o = WebGLTransformFeedback::create(this);
-  addSharedObject(o);
-  return o;
+  return WebGLTransformFeedback::create(this);
 }
 
 void WebGL2RenderingContextBase::deleteTransformFeedback(
     WebGLTransformFeedback* feedback) {
   if (feedback == m_transformFeedbackBinding)
     m_transformFeedbackBinding = nullptr;
 
   deleteObject(feedback);
 }
 
@@ skipping 487 matching lines @@
     return;
 
   contextGL()->UniformBlockBinding(objectOrZero(program), uniformBlockIndex,
                                    uniformBlockBinding);
 }
 
 WebGLVertexArrayObject* WebGL2RenderingContextBase::createVertexArray() {
   if (isContextLost())
     return nullptr;
 
-  WebGLVertexArrayObject* o = WebGLVertexArrayObject::create(
+  return WebGLVertexArrayObject::create(
       this, WebGLVertexArrayObjectBase::VaoTypeUser);
-  addContextObject(o);
-  return o;
 }
 
 void WebGL2RenderingContextBase::deleteVertexArray(
     WebGLVertexArrayObject* vertexArray) {
   if (isContextLost() || !vertexArray)
     return;
 
   if (!vertexArray->isDefaultObject() &&
       vertexArray == m_boundVertexArrayObject)
     setBoundVertexArrayObject(nullptr);
@@ skipping 1135 matching lines @@
 
 void WebGL2RenderingContextBase::
     DrawingBufferClientRestorePixelUnpackBufferBinding() {
   if (!contextGL())
     return;
   contextGL()->BindBuffer(GL_PIXEL_UNPACK_BUFFER,
                           objectOrZero(m_boundPixelUnpackBuffer.get()));
 }
 
 }  // namespace blink