[Oilpan] Migrate classes under module/webgl onto oilpan heap

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 228 matching lines @@
 
     ~ScopedDrawingBufferBinder()
     {
         // Restore DrawingBuffer if needed
         if (!m_readFramebufferBinding && m_drawingBuffer)
             m_drawingBuffer->restoreFramebufferBindings();
     }
 
 private:
     DrawingBuffer* m_drawingBuffer;
-    RawPtrWillBeMember<WebGLFramebuffer> m_readFramebufferBinding;
+    Member<WebGLFramebuffer> m_readFramebufferBinding;
 };
 
 GLint clamp(GLint value, GLint min, GLint max)
 {
     if (value < min)
         value = min;
     if (value > max)
         value = max;
     return value;
 }
@@ skipping 234 matching lines @@
 
     ~ScopedFramebufferRestorer()
     {
         m_context->restoreCurrentFramebuffer();
     }
 
 private:
     RawPtrWillBeMember<WebGLRenderingContextBase> m_context;
 };
 
-class WebGLRenderingContextLostCallback final : public NoBaseWillBeGarbageCollectedFinalized<WebGLRenderingContextLostCallback>, public WebGraphicsContext3D::WebGraphicsContextLostCallback {
-    WTF_MAKE_FAST_ALLOCATED_WILL_BE_REMOVED(WebGLRenderingContextLostCallback);
+class WebGLRenderingContextLostCallback final : public GarbageCollectedFinalized<WebGLRenderingContextLostCallback>, public WebGraphicsContext3D::WebGraphicsContextLostCallback {
 public:
-    static PassOwnPtrWillBeRawPtr<WebGLRenderingContextLostCallback> create(WebGLRenderingContextBase* context)
+    static WebGLRenderingContextLostCallback* create(WebGLRenderingContextBase* context)
     {
-        return adoptPtrWillBeNoop(new WebGLRenderingContextLostCallback(context));
+        return new WebGLRenderingContextLostCallback(context);
     }
 
     ~WebGLRenderingContextLostCallback() override { }
 
     virtual void onContextLost() { m_context->forceLostContext(WebGLRenderingContextBase::RealLostContext, WebGLRenderingContextBase::Auto); }
 
     DEFINE_INLINE_TRACE()
     {
         visitor->trace(m_context);
     }
 
 private:
     explicit WebGLRenderingContextLostCallback(WebGLRenderingContextBase* context)
         : m_context(context) { }
 
     RawPtrWillBeMember<WebGLRenderingContextBase> m_context;
 };
 
-class WebGLRenderingContextErrorMessageCallback final : public NoBaseWillBeGarbageCollectedFinalized<WebGLRenderingContextErrorMessageCallback>, public WebGraphicsContext3D::WebGraphicsErrorMessageCallback {
-    WTF_MAKE_FAST_ALLOCATED_WILL_BE_REMOVED(WebGLRenderingContextErrorMessageCallback);
+class WebGLRenderingContextErrorMessageCallback final : public GarbageCollectedFinalized<WebGLRenderingContextErrorMessageCallback>, public WebGraphicsContext3D::WebGraphicsErrorMessageCallback {
 public:
-    static PassOwnPtrWillBeRawPtr<WebGLRenderingContextErrorMessageCallback> create(WebGLRenderingContextBase* context)
+    static WebGLRenderingContextErrorMessageCallback* create(WebGLRenderingContextBase* context)
     {
-        return adoptPtrWillBeNoop(new WebGLRenderingContextErrorMessageCallback(context));
+        return new WebGLRenderingContextErrorMessageCallback(context);
     }
 
     ~WebGLRenderingContextErrorMessageCallback() override { }
 
     virtual void onErrorMessage(const WebString& message, WGC3Dint)
     {
         if (m_context->m_synthesizedErrorsToConsole)
             m_context->printGLErrorToConsole(message);
         InspectorInstrumentation::didFireWebGLErrorOrWarning(m_context->canvas(), message);
     }
@@ skipping 1379 matching lines @@
         return;
     }
     WebGLFramebuffer* readFramebufferBinding = nullptr;
     if (!validateReadBufferAndGetInfo("copyTexSubImage2D", readFramebufferBinding, nullptr, nullptr))
         return;
     clearIfComposited();
     ScopedDrawingBufferBinder binder(drawingBuffer(), readFramebufferBinding);
     webContext()->copyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height);
 }
 
-PassRefPtrWillBeRawPtr<WebGLBuffer> WebGLRenderingContextBase::createBuffer()
+WebGLBuffer* WebGLRenderingContextBase::createBuffer()
 {
     if (isContextLost())
         return nullptr;
-    RefPtrWillBeRawPtr<WebGLBuffer> o = WebGLBuffer::create(this);
-    addSharedObject(o.get());
-    return o.release();
+    WebGLBuffer* o = WebGLBuffer::create(this);
+    addSharedObject(o);
+    return o;
 }
 
-PassRefPtrWillBeRawPtr<WebGLFramebuffer> WebGLRenderingContextBase::createFramebuffer()
+WebGLFramebuffer* WebGLRenderingContextBase::createFramebuffer()
 {
     if (isContextLost())
         return nullptr;
-    RefPtrWillBeRawPtr<WebGLFramebuffer> o = WebGLFramebuffer::create(this);
-    addContextObject(o.get());
-    return o.release();
+    WebGLFramebuffer* o = WebGLFramebuffer::create(this);
+    addContextObject(o);
+    return o;
 }
 
-PassRefPtrWillBeRawPtr<WebGLTexture> WebGLRenderingContextBase::createTexture()
+WebGLTexture* WebGLRenderingContextBase::createTexture()
 {
     if (isContextLost())
         return nullptr;
-    RefPtrWillBeRawPtr<WebGLTexture> o = WebGLTexture::create(this);
-    addSharedObject(o.get());
-    return o.release();
+    WebGLTexture* o = WebGLTexture::create(this);
+    addSharedObject(o);
+    return o;
 }
 
-PassRefPtrWillBeRawPtr<WebGLProgram> WebGLRenderingContextBase::createProgram()
+WebGLProgram* WebGLRenderingContextBase::createProgram()
 {
     if (isContextLost())
         return nullptr;
-    RefPtrWillBeRawPtr<WebGLProgram> o = WebGLProgram::create(this);
-    addSharedObject(o.get());
-    return o.release();
+    WebGLProgram* o = WebGLProgram::create(this);
+    addSharedObject(o);
+    return o;
 }
 
-PassRefPtrWillBeRawPtr<WebGLRenderbuffer> WebGLRenderingContextBase::createRenderbuffer()
+WebGLRenderbuffer* WebGLRenderingContextBase::createRenderbuffer()
 {
     if (isContextLost())
         return nullptr;
-    RefPtrWillBeRawPtr<WebGLRenderbuffer> o = WebGLRenderbuffer::create(this);
-    addSharedObject(o.get());
-    return o.release();
+    WebGLRenderbuffer* o = WebGLRenderbuffer::create(this);
+    addSharedObject(o);
+    return o;
 }
 
 WebGLRenderbuffer* WebGLRenderingContextBase::ensureEmulatedStencilBuffer(GLenum target, WebGLRenderbuffer* renderbuffer)
 {
     if (isContextLost())
         return nullptr;
     if (!renderbuffer->emulatedStencilBuffer()) {
         renderbuffer->setEmulatedStencilBuffer(createRenderbuffer());
         webContext()->bindRenderbuffer(target, objectOrZero(renderbuffer->emulatedStencilBuffer()));
         webContext()->bindRenderbuffer(target, objectOrZero(m_renderbufferBinding.get()));
     }
     return renderbuffer->emulatedStencilBuffer();
 }
 
-PassRefPtrWillBeRawPtr<WebGLShader> WebGLRenderingContextBase::createShader(GLenum type)
+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;
     }
 
-    RefPtrWillBeRawPtr<WebGLShader> o = WebGLShader::create(this, type);
-    addSharedObject(o.get());
-    return o.release();
+    WebGLShader* o = WebGLShader::create(this, type);
+    addSharedObject(o);
+    return o;
 }
 
 void WebGLRenderingContextBase::cullFace(GLenum mode)
 {
     if (isContextLost())
         return;
     switch (mode) {
     case GL_FRONT_AND_BACK:
     case GL_FRONT:
     case GL_BACK:
@@ skipping 435 matching lines @@
     }
 #endif
     webContext()->generateMipmap(target);
 #if OS(MACOSX)
     if (needToResetMinFilter)
         webContext()->texParameteri(target, GL_TEXTURE_MIN_FILTER, tex->getMinFilter());
 #endif
     tex->generateMipmapLevelInfo();
 }
 
-PassRefPtrWillBeRawPtr<WebGLActiveInfo> WebGLRenderingContextBase::getActiveAttrib(WebGLProgram* program, GLuint index)
+WebGLActiveInfo* WebGLRenderingContextBase::getActiveAttrib(WebGLProgram* program, GLuint index)
 {
     if (isContextLost() || !validateWebGLObject("getActiveAttrib", program))
         return nullptr;
     WebGraphicsContext3D::ActiveInfo info;
     if (!webContext()->getActiveAttrib(objectOrZero(program), index, info))
         return nullptr;
     return WebGLActiveInfo::create(info.name, info.type, info.size);
 }
 
-PassRefPtrWillBeRawPtr<WebGLActiveInfo> WebGLRenderingContextBase::getActiveUniform(WebGLProgram* program, GLuint index)
+WebGLActiveInfo* WebGLRenderingContextBase::getActiveUniform(WebGLProgram* program, GLuint index)
 {
     if (isContextLost() || !validateWebGLObject("getActiveUniform", program))
         return nullptr;
     WebGraphicsContext3D::ActiveInfo info;
     if (!webContext()->getActiveUniform(objectOrZero(program), index, info))
         return nullptr;
     return WebGLActiveInfo::create(info.name, info.type, info.size);
 }
 
-Nullable<WillBeHeapVector<RefPtrWillBeMember<WebGLShader>>> WebGLRenderingContextBase::getAttachedShaders(WebGLProgram* program)
+Nullable<HeapVector<Member<WebGLShader>>> WebGLRenderingContextBase::getAttachedShaders(WebGLProgram* program)
 {
     if (isContextLost() || !validateWebGLObject("getAttachedShaders", program))
         return nullptr;
 
-    WillBeHeapVector<RefPtrWillBeMember<WebGLShader>> shaderObjects;
+    HeapVector<Member<WebGLShader>> shaderObjects;
     const GLenum shaderType[] = {
         GL_VERTEX_SHADER,
         GL_FRAGMENT_SHADER
     };
     for (unsigned i = 0; i < sizeof(shaderType) / sizeof(GLenum); ++i) {
         WebGLShader* shader = program->getAttachedShader(shaderType[i]);
         if (shader)
             shaderObjects.append(shader);
     }
     return shaderObjects;
@@ skipping 105 matching lines @@
 {
     if (tracker->draft() && !RuntimeEnabledFeatures::webGLDraftExtensionsEnabled())
         return false;
     if (!tracker->supported(this))
         return false;
     return true;
 }
 
 ScriptValue WebGLRenderingContextBase::getExtension(ScriptState* scriptState, const String& name)
 {
-    RefPtrWillBeRawPtr<WebGLExtension> extension = nullptr;
+    WebGLExtension* extension = nullptr;
 
     if (!isContextLost()) {
         for (size_t i = 0; i < m_extensions.size(); ++i) {
-            ExtensionTracker* tracker = m_extensions[i].get();
+            ExtensionTracker* tracker = m_extensions[i];
             if (tracker->matchesNameWithPrefixes(name)) {
                 if (extensionSupportedAndAllowed(tracker)) {
                     extension = tracker->getExtension(this);
                     if (extension)
                         m_extensionEnabled[extension->name()] = true;
                 }
                 break;
             }
         }
     }
@@ skipping 20 matching lines @@
         synthesizeGLError(GL_INVALID_ENUM, "getFramebufferAttachmentParameter", "invalid parameter name");
         return ScriptValue::createNull(scriptState);
     }
 
     ASSERT(attachmentObject->isTexture() || attachmentObject->isRenderbuffer());
     if (attachmentObject->isTexture()) {
         switch (pname) {
         case GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE:
             return WebGLAny(scriptState, GL_TEXTURE);
         case GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME:
-            return WebGLAny(scriptState, PassRefPtrWillBeRawPtr<WebGLObject>(attachmentObject));
+            return WebGLAny(scriptState, attachmentObject);
         case GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL:
         case GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE:
             {
                 GLint value = 0;
                 webContext()->getFramebufferAttachmentParameteriv(target, attachment, pname, &value);
                 return WebGLAny(scriptState, value);
             }
         case GL_FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING_EXT:
             if (extensionEnabled(EXTsRGBName)) {
                 GLint value = 0;
                 webContext()->getFramebufferAttachmentParameteriv(target, attachment, pname, &value);
                 return WebGLAny(scriptState, static_cast<unsigned>(value));
             }
             synthesizeGLError(GL_INVALID_ENUM, "getFramebufferAttachmentParameter", "invalid parameter name for renderbuffer attachment");
             return ScriptValue::createNull(scriptState);
         default:
             synthesizeGLError(GL_INVALID_ENUM, "getFramebufferAttachmentParameter", "invalid parameter name for texture attachment");
             return ScriptValue::createNull(scriptState);
         }
     } else {
         switch (pname) {
         case GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE:
             return WebGLAny(scriptState, GL_RENDERBUFFER);
         case GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME:
-            return WebGLAny(scriptState, PassRefPtrWillBeRawPtr<WebGLObject>(attachmentObject));
+            return WebGLAny(scriptState, attachmentObject);
         case GL_FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING_EXT:
             if (extensionEnabled(EXTsRGBName) || isWebGL2OrHigher()) {
                 GLint value = 0;
                 webContext()->getFramebufferAttachmentParameteriv(target, attachment, pname, &value);
                 return WebGLAny(scriptState, value);
             }
             synthesizeGLError(GL_INVALID_ENUM, "getFramebufferAttachmentParameter", "invalid parameter name for renderbuffer attachment");
             return ScriptValue::createNull(scriptState);
         default:
             synthesizeGLError(GL_INVALID_ENUM, "getFramebufferAttachmentParameter", "invalid parameter name for renderbuffer attachment");
@@ skipping 10 matching lines @@
     switch (pname) {
     case GL_ACTIVE_TEXTURE:
         return getUnsignedIntParameter(scriptState, pname);
     case GL_ALIASED_LINE_WIDTH_RANGE:
         return getWebGLFloatArrayParameter(scriptState, pname);
     case GL_ALIASED_POINT_SIZE_RANGE:
         return getWebGLFloatArrayParameter(scriptState, pname);
     case GL_ALPHA_BITS:
         return getIntParameter(scriptState, pname);
     case GL_ARRAY_BUFFER_BINDING:
-        return WebGLAny(scriptState, PassRefPtrWillBeRawPtr<WebGLObject>(m_boundArrayBuffer.get()));
+        return WebGLAny(scriptState, m_boundArrayBuffer.get());
     case GL_BLEND:
         return getBooleanParameter(scriptState, pname);
     case GL_BLEND_COLOR:
         return getWebGLFloatArrayParameter(scriptState, pname);
     case GL_BLEND_DST_ALPHA:
         return getUnsignedIntParameter(scriptState, pname);
     case GL_BLEND_DST_RGB:
         return getUnsignedIntParameter(scriptState, pname);
     case GL_BLEND_EQUATION_ALPHA:
         return getUnsignedIntParameter(scriptState, pname);
     case GL_BLEND_EQUATION_RGB:
         return getUnsignedIntParameter(scriptState, pname);
     case GL_BLEND_SRC_ALPHA:
         return getUnsignedIntParameter(scriptState, pname);
     case GL_BLEND_SRC_RGB:
         return getUnsignedIntParameter(scriptState, pname);
     case GL_BLUE_BITS:
         return getIntParameter(scriptState, pname);
     case GL_COLOR_CLEAR_VALUE:
         return getWebGLFloatArrayParameter(scriptState, pname);
     case GL_COLOR_WRITEMASK:
         return getBooleanArrayParameter(scriptState, pname);
     case GL_COMPRESSED_TEXTURE_FORMATS:
         return WebGLAny(scriptState, DOMUint32Array::create(m_compressedTextureFormats.data(), m_compressedTextureFormats.size()));
     case GL_CULL_FACE:
         return getBooleanParameter(scriptState, pname);
     case GL_CULL_FACE_MODE:
         return getUnsignedIntParameter(scriptState, pname);
     case GL_CURRENT_PROGRAM:
-        return WebGLAny(scriptState, PassRefPtrWillBeRawPtr<WebGLObject>(m_currentProgram.get()));
+        return WebGLAny(scriptState, m_currentProgram.get());
     case GL_DEPTH_BITS:
         if (!m_framebufferBinding && !m_requestedAttributes.depth())
             return WebGLAny(scriptState, intZero);
         return getIntParameter(scriptState, pname);
     case GL_DEPTH_CLEAR_VALUE:
         return getFloatParameter(scriptState, pname);
     case GL_DEPTH_FUNC:
         return getUnsignedIntParameter(scriptState, pname);
     case GL_DEPTH_RANGE:
         return getWebGLFloatArrayParameter(scriptState, pname);
     case GL_DEPTH_TEST:
         return getBooleanParameter(scriptState, pname);
     case GL_DEPTH_WRITEMASK:
         return getBooleanParameter(scriptState, pname);
     case GL_DITHER:
         return getBooleanParameter(scriptState, pname);
     case GL_ELEMENT_ARRAY_BUFFER_BINDING:
-        return WebGLAny(scriptState, PassRefPtrWillBeRawPtr<WebGLObject>(m_boundVertexArrayObject->boundElementArrayBuffer()));
+        return WebGLAny(scriptState, m_boundVertexArrayObject->boundElementArrayBuffer());
     case GL_FRAMEBUFFER_BINDING:
-        return WebGLAny(scriptState, PassRefPtrWillBeRawPtr<WebGLObject>(m_framebufferBinding.get()));
+        return WebGLAny(scriptState, m_framebufferBinding.get());
     case GL_FRONT_FACE:
         return getUnsignedIntParameter(scriptState, pname);
     case GL_GENERATE_MIPMAP_HINT:
         return getUnsignedIntParameter(scriptState, pname);
     case GL_GREEN_BITS:
         return getIntParameter(scriptState, pname);
     case GL_IMPLEMENTATION_COLOR_READ_FORMAT:
         return getIntParameter(scriptState, pname);
     case GL_IMPLEMENTATION_COLOR_READ_TYPE:
         return getIntParameter(scriptState, pname);
@@ skipping 28 matching lines @@
         return getIntParameter(scriptState, pname);
     case GL_POLYGON_OFFSET_FACTOR:
         return getFloatParameter(scriptState, pname);
     case GL_POLYGON_OFFSET_FILL:
         return getBooleanParameter(scriptState, pname);
     case GL_POLYGON_OFFSET_UNITS:
         return getFloatParameter(scriptState, pname);
     case GL_RED_BITS:
         return getIntParameter(scriptState, pname);
     case GL_RENDERBUFFER_BINDING:
-        return WebGLAny(scriptState, PassRefPtrWillBeRawPtr<WebGLObject>(m_renderbufferBinding.get()));
+        return WebGLAny(scriptState, m_renderbufferBinding.get());
     case GL_RENDERER:
         return WebGLAny(scriptState, String("WebKit WebGL"));
     case GL_SAMPLE_BUFFERS:
         return getIntParameter(scriptState, pname);
     case GL_SAMPLE_COVERAGE_INVERT:
         return getBooleanParameter(scriptState, pname);
     case GL_SAMPLE_COVERAGE_VALUE:
         return getFloatParameter(scriptState, pname);
     case GL_SAMPLES:
         return getIntParameter(scriptState, pname);
@@ skipping 35 matching lines @@
         return getIntParameter(scriptState, pname);
     case GL_STENCIL_TEST:
         return getBooleanParameter(scriptState, pname);
     case GL_STENCIL_VALUE_MASK:
         return getUnsignedIntParameter(scriptState, pname);
     case GL_STENCIL_WRITEMASK:
         return getUnsignedIntParameter(scriptState, pname);
     case GL_SUBPIXEL_BITS:
         return getIntParameter(scriptState, pname);
     case GL_TEXTURE_BINDING_2D:
-        return WebGLAny(scriptState, PassRefPtrWillBeRawPtr<WebGLObject>(m_textureUnits[m_activeTextureUnit].m_texture2DBinding.get()));
+        return WebGLAny(scriptState, m_textureUnits[m_activeTextureUnit].m_texture2DBinding.get());
     case GL_TEXTURE_BINDING_CUBE_MAP:
-        return WebGLAny(scriptState, PassRefPtrWillBeRawPtr<WebGLObject>(m_textureUnits[m_activeTextureUnit].m_textureCubeMapBinding.get()));
+        return WebGLAny(scriptState, m_textureUnits[m_activeTextureUnit].m_textureCubeMapBinding.get());
     case GL_UNPACK_ALIGNMENT:
         return getIntParameter(scriptState, pname);
     case GC3D_UNPACK_FLIP_Y_WEBGL:
         return WebGLAny(scriptState, m_unpackFlipY);
     case GC3D_UNPACK_PREMULTIPLY_ALPHA_WEBGL:
         return WebGLAny(scriptState, m_unpackPremultiplyAlpha);
     case GC3D_UNPACK_COLORSPACE_CONVERSION_WEBGL:
         return WebGLAny(scriptState, m_unpackColorspaceConversion);
     case GL_VENDOR:
         return WebGLAny(scriptState, String("WebKit"));
@@ skipping 12 matching lines @@
         synthesizeGLError(GL_INVALID_ENUM, "getParameter", "invalid parameter name, WEBGL_debug_renderer_info not enabled");
         return ScriptValue::createNull(scriptState);
     case WebGLDebugRendererInfo::UNMASKED_VENDOR_WEBGL:
         if (extensionEnabled(WebGLDebugRendererInfoName))
             return WebGLAny(scriptState, webContext()->getString(GL_VENDOR));
         synthesizeGLError(GL_INVALID_ENUM, "getParameter", "invalid parameter name, WEBGL_debug_renderer_info not enabled");
         return ScriptValue::createNull(scriptState);
     case GL_VERTEX_ARRAY_BINDING_OES: // OES_vertex_array_object
         if (extensionEnabled(OESVertexArrayObjectName) || isWebGL2OrHigher()) {
             if (!m_boundVertexArrayObject->isDefaultObject())
-                return WebGLAny(scriptState, PassRefPtrWillBeRawPtr<WebGLObject>(m_boundVertexArrayObject.get()));
+                return WebGLAny(scriptState, m_boundVertexArrayObject.get());
             return ScriptValue::createNull(scriptState);
         }
         synthesizeGLError(GL_INVALID_ENUM, "getParameter", "invalid parameter name, OES_vertex_array_object not enabled");
         return ScriptValue::createNull(scriptState);
     case GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT: // EXT_texture_filter_anisotropic
         if (extensionEnabled(EXTTextureFilterAnisotropicName))
             return getUnsignedIntParameter(scriptState, GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT);
         synthesizeGLError(GL_INVALID_ENUM, "getParameter", "invalid parameter name, EXT_texture_filter_anisotropic not enabled");
         return ScriptValue::createNull(scriptState);
     case GL_MAX_COLOR_ATTACHMENTS_EXT: // EXT_draw_buffers BEGIN
@@ skipping 131 matching lines @@
     }
 }
 
 String WebGLRenderingContextBase::getShaderInfoLog(WebGLShader* shader)
 {
     if (isContextLost() || !validateWebGLObject("getShaderInfoLog", shader))
         return String();
     return ensureNotNull(webContext()->getShaderInfoLog(objectOrZero(shader)));
 }
 
-PassRefPtrWillBeRawPtr<WebGLShaderPrecisionFormat> WebGLRenderingContextBase::getShaderPrecisionFormat(GLenum shaderType, GLenum precisionType)
+WebGLShaderPrecisionFormat* WebGLRenderingContextBase::getShaderPrecisionFormat(GLenum shaderType, GLenum precisionType)
 {
     if (isContextLost())
         return nullptr;
     switch (shaderType) {
     case GL_VERTEX_SHADER:
     case GL_FRAGMENT_SHADER:
         break;
     default:
         synthesizeGLError(GL_INVALID_ENUM, "getShaderPrecisionFormat", "invalid shader type");
         return nullptr;
@@ skipping 275 matching lines @@
                     notImplemented();
                 }
             }
         }
     }
     // If we get here, something went wrong in our unfortunately complex logic above
     synthesizeGLError(GL_INVALID_VALUE, "getUniform", "unknown error");
     return ScriptValue::createNull(scriptState);
 }
 
-PassRefPtrWillBeRawPtr<WebGLUniformLocation> WebGLRenderingContextBase::getUniformLocation(WebGLProgram* program, const String& name)
+WebGLUniformLocation* WebGLRenderingContextBase::getUniformLocation(WebGLProgram* program, const String& name)
 {
     if (isContextLost() || !validateWebGLObject("getUniformLocation", program))
         return nullptr;
     if (!validateLocationLength("getUniformLocation", name))
         return nullptr;
     if (!validateString("getUniformLocation", name))
         return nullptr;
     if (isPrefixReserved(name))
         return nullptr;
     if (!program->linkStatus()) {
@@ skipping 17 matching lines @@
     const WebGLVertexArrayObjectBase::VertexAttribState* state = m_boundVertexArrayObject->getVertexAttribState(index);
 
     if ((extensionEnabled(ANGLEInstancedArraysName) || isWebGL2OrHigher())
         && pname == GL_VERTEX_ATTRIB_ARRAY_DIVISOR_ANGLE)
         return WebGLAny(scriptState, state->divisor);
 
     switch (pname) {
     case GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING:
         if (!state->bufferBinding || !state->bufferBinding->object())
             return ScriptValue::createNull(scriptState);
-        return WebGLAny(scriptState, PassRefPtrWillBeRawPtr<WebGLObject>(state->bufferBinding.get()));
+        return WebGLAny(scriptState, state->bufferBinding.get());
     case GL_VERTEX_ATTRIB_ARRAY_ENABLED:
         return WebGLAny(scriptState, state->enabled);
     case GL_VERTEX_ATTRIB_ARRAY_NORMALIZED:
         return WebGLAny(scriptState, state->normalized);
     case GL_VERTEX_ATTRIB_ARRAY_SIZE:
         return WebGLAny(scriptState, state->size);
     case GL_VERTEX_ATTRIB_ARRAY_STRIDE:
         return WebGLAny(scriptState, state->originalStride);
     case GL_VERTEX_ATTRIB_ARRAY_TYPE:
         return WebGLAny(scriptState, state->type);
@@ skipping 573 matching lines @@
     webContext()->stencilOp(fail, zfail, zpass);
 }
 
 void WebGLRenderingContextBase::stencilOpSeparate(GLenum face, GLenum fail, GLenum zfail, GLenum zpass)
 {
     if (isContextLost())
         return;
     webContext()->stencilOpSeparate(face, fail, zfail, zpass);
 }
 
-PassRefPtrWillBeRawPtr<CHROMIUMValuebuffer> WebGLRenderingContextBase::createValuebufferCHROMIUM()
+CHROMIUMValuebuffer* WebGLRenderingContextBase::createValuebufferCHROMIUM()
 {
     if (isContextLost())
         return nullptr;
-    RefPtrWillBeRawPtr<CHROMIUMValuebuffer> o = CHROMIUMValuebuffer::create(this);
-    addSharedObject(o.get());
-    return o.release();
+    CHROMIUMValuebuffer* o = CHROMIUMValuebuffer::create(this);
+    addSharedObject(o);
+    return o;
 }
 
 void WebGLRenderingContextBase::deleteValuebufferCHROMIUM(CHROMIUMValuebuffer *valuebuffer)
 {
     if (!deleteObject(valuebuffer))
         return;
     if (valuebuffer == m_valuebufferBinding)
         m_valuebufferBinding = nullptr;
 }
 
@@ skipping 1155 matching lines @@
 
 void WebGLRenderingContextBase::addContextObject(WebGLContextObject* object)
 {
     ASSERT(!isContextLost());
     m_contextObjects.add(object);
 }
 
 void WebGLRenderingContextBase::detachAndRemoveAllObjects()
 {
     while (m_contextObjects.size() > 0) {
-        WillBeHeapHashSet<RawPtrWillBeWeakMember<WebGLContextObject>>::iterator it = m_contextObjects.begin();
+        // 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);
     }
@@ skipping 881 matching lines @@
         return false;
     }
     return true;
 }
 
 WebGLBuffer* WebGLRenderingContextBase::validateBufferDataTarget(const char* functionName, GLenum target)
 {
     WebGLBuffer* buffer = nullptr;
     switch (target) {
     case GL_ELEMENT_ARRAY_BUFFER:
-        buffer = m_boundVertexArrayObject->boundElementArrayBuffer().get();
+        buffer = m_boundVertexArrayObject->boundElementArrayBuffer();
         break;
     case GL_ARRAY_BUFFER:
         buffer = m_boundArrayBuffer.get();
         break;
     default:
         synthesizeGLError(GL_INVALID_ENUM, functionName, "invalid target");
         return nullptr;
     }
     if (!buffer) {
         synthesizeGLError(GL_INVALID_OPERATION, functionName, "no buffer");
@@ skipping 505 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)
 {
-#if ENABLE(OILPAN)
     visitor->trace(m_contextObjects);
     visitor->trace(m_contextLostCallbackAdapter);
     visitor->trace(m_errorMessageCallbackAdapter);
     visitor->trace(m_boundArrayBuffer);
     visitor->trace(m_defaultVertexArrayObject);
     visitor->trace(m_boundVertexArrayObject);
     visitor->trace(m_vertexAttrib0Buffer);
     visitor->trace(m_currentProgram);
     visitor->trace(m_framebufferBinding);
     visitor->trace(m_renderbufferBinding);
     visitor->trace(m_valuebufferBinding);
     visitor->trace(m_textureUnits);
     visitor->trace(m_blackTexture2D);
     visitor->trace(m_blackTextureCubeMap);
-    visitor->trace(m_requestedAttributes);
     visitor->trace(m_extensions);
-#endif
     CanvasRenderingContext::trace(visitor);
 }
 
 int WebGLRenderingContextBase::externallyAllocatedBytesPerPixel()
 {
     if (isContextLost())
         return 0;
 
     int bytesPerPixel = 4;
     int totalBytesPerPixel = bytesPerPixel * 2; // WebGL's front and back color buffers.
@@ skipping 15 matching lines @@
 
     return totalBytesPerPixel;
 }
 
 DrawingBuffer* WebGLRenderingContextBase::drawingBuffer() const
 {
     return m_drawingBuffer.get();
 }
 
 } // namespace blink