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

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 "config.h"
 #include "modules/webgl/WebGL2RenderingContextBase.h"
 
 #include "bindings/modules/v8/WebGLAny.h"
 #include "core/html/HTMLCanvasElement.h"
 #include "core/html/HTMLImageElement.h"
@@ skipping 1103 matching lines @@
 }
 
 void WebGL2RenderingContextBase::clearBufferfi(GLenum buffer, GLint drawbuffer, GLfloat depth, GLint stencil)
 {
     if (isContextLost())
         return;
 
     webContext()->clearBufferfi(buffer, drawbuffer, depth, stencil);
 }
 
-PassRefPtrWillBeRawPtr<WebGLQuery> WebGL2RenderingContextBase::createQuery()
+WebGLQuery* WebGL2RenderingContextBase::createQuery()
 {
     if (isContextLost())
         return nullptr;
-    RefPtrWillBeRawPtr<WebGLQuery> o = WebGLQuery::create(this);
-    addSharedObject(o.get());
+    WebGLQuery* o = WebGLQuery::create(this);
+    addSharedObject(o);
     return o;
 }
 
 void WebGL2RenderingContextBase::deleteQuery(WebGLQuery* query)
 {
     if (m_currentBooleanOcclusionQuery == query) {
         webContext()->endQueryEXT(m_currentBooleanOcclusionQuery->getTarget());
         m_currentBooleanOcclusionQuery = nullptr;
     }
 
@@ skipping 87 matching lines @@
         }
         break;
     default:
         synthesizeGLError(GL_INVALID_ENUM, "endQuery", "invalid target");
         return;
     }
 
     webContext()->endQueryEXT(target);
 }
 
-PassRefPtrWillBeRawPtr<WebGLQuery> WebGL2RenderingContextBase::getQuery(GLenum target, GLenum pname)
+WebGLQuery* WebGL2RenderingContextBase::getQuery(GLenum target, GLenum pname)
 {
     if (isContextLost())
         return nullptr;
 
     if (pname != GL_CURRENT_QUERY) {
         synthesizeGLError(GL_INVALID_ENUM, "getQuery", "invalid parameter name");
         return nullptr;
     }
 
     switch (target) {
     case GL_ANY_SAMPLES_PASSED:
     case GL_ANY_SAMPLES_PASSED_CONSERVATIVE:
         if (m_currentBooleanOcclusionQuery && m_currentBooleanOcclusionQuery->getTarget() == target)
-            return PassRefPtrWillBeRawPtr<WebGLQuery>(m_currentBooleanOcclusionQuery.get());
+            return m_currentBooleanOcclusionQuery;
         break;
     case GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN:
-        return PassRefPtrWillBeRawPtr<WebGLQuery>(m_currentTransformFeedbackPrimitivesWrittenQuery.get());
+        return m_currentTransformFeedbackPrimitivesWrittenQuery;
     default:
         synthesizeGLError(GL_INVALID_ENUM, "getQuery", "invalid target");
         return nullptr;
     }
     return nullptr;
 }
 
 ScriptValue WebGL2RenderingContextBase::getQueryParameter(ScriptState* scriptState, WebGLQuery* query, GLenum pname)
 {
     if (isContextLost() || !validateWebGLObject("getQueryParameter", query))
@@ skipping 11 matching lines @@
             GLuint value;
             webContext()->getQueryObjectuivEXT(objectOrZero(query), pname, &value);
             return WebGLAny(scriptState, value == GL_TRUE);
         }
     default:
         synthesizeGLError(GL_INVALID_ENUM, "getQueryParameter", "invalid parameter name");
         return ScriptValue::createNull(scriptState);
     }
 }
 
-PassRefPtrWillBeRawPtr<WebGLSampler> WebGL2RenderingContextBase::createSampler()
+WebGLSampler* WebGL2RenderingContextBase::createSampler()
 {
     if (isContextLost())
         return nullptr;
-    RefPtrWillBeRawPtr<WebGLSampler> o = WebGLSampler::create(this);
-    addSharedObject(o.get());
+    WebGLSampler* o = WebGLSampler::create(this);
+    addSharedObject(o);
     return o;
 }
 
 void WebGL2RenderingContextBase::deleteSampler(WebGLSampler* sampler)
 {
     for (size_t i = 0; i < m_samplerUnits.size(); ++i) {
         if (sampler == m_samplerUnits[i]) {
             m_samplerUnits[i] = nullptr;
             webContext()->bindSampler(i, 0);
         }
@@ skipping 70 matching lines @@
             GLfloat value = 0.f;
             webContext()->getSamplerParameterfv(objectOrZero(sampler), pname, &value);
             return WebGLAny(scriptState, value);
         }
     default:
         synthesizeGLError(GL_INVALID_ENUM, "getSamplerParameter", "invalid parameter name");
         return ScriptValue::createNull(scriptState);
     }
 }
 
-PassRefPtrWillBeRawPtr<WebGLSync> WebGL2RenderingContextBase::fenceSync(GLenum condition, GLbitfield flags)
+WebGLSync* WebGL2RenderingContextBase::fenceSync(GLenum condition, GLbitfield flags)
 {
     if (isContextLost())
         return nullptr;
 
-    RefPtrWillBeRawPtr<WebGLSync> o = WebGLFenceSync::create(this, condition, flags);
-    addSharedObject(o.get());
-    return o.release();
+    WebGLSync* o = WebGLFenceSync::create(this, condition, flags);
+    addSharedObject(o);
+    return o;
 }
 
 GLboolean WebGL2RenderingContextBase::isSync(WebGLSync* sync)
 {
     if (isContextLost() || !sync)
         return 0;
 
     return webContext()->isSync(sync->object());
 }
 
@@ skipping 45 matching lines @@
             GLsizei length = -1;
             webContext()->getSynciv(syncObjectOrZero(sync), pname, 1, &length, &value);
             return WebGLAny(scriptState, static_cast<unsigned>(value));
         }
     default:
         synthesizeGLError(GL_INVALID_ENUM, "getSyncParameter", "invalid parameter name");
         return ScriptValue::createNull(scriptState);
     }
 }
 
-PassRefPtrWillBeRawPtr<WebGLTransformFeedback> WebGL2RenderingContextBase::createTransformFeedback()
+WebGLTransformFeedback* WebGL2RenderingContextBase::createTransformFeedback()
 {
     if (isContextLost())
         return nullptr;
-    RefPtrWillBeRawPtr<WebGLTransformFeedback> o = WebGLTransformFeedback::create(this);
-    addSharedObject(o.get());
+    WebGLTransformFeedback* o = WebGLTransformFeedback::create(this);
+    addSharedObject(o);
     return o;
 }
 
 void WebGL2RenderingContextBase::deleteTransformFeedback(WebGLTransformFeedback* feedback)
 {
     if (feedback == m_transformFeedbackBinding)
         m_transformFeedbackBinding = nullptr;
 
     deleteObject(feedback);
 }
@@ skipping 55 matching lines @@
     Vector<CString> keepAlive; // Must keep these instances alive while looking at their data
     Vector<const char*> varyingStrings;
     for (size_t i = 0; i < varyings.size(); ++i) {
         keepAlive.append(varyings[i].ascii());
         varyingStrings.append(keepAlive.last().data());
     }
 
     webContext()->transformFeedbackVaryings(objectOrZero(program), varyings.size(), varyingStrings.data(), bufferMode);
 }
 
-PassRefPtrWillBeRawPtr<WebGLActiveInfo> WebGL2RenderingContextBase::getTransformFeedbackVarying(WebGLProgram* program, GLuint index)
+WebGLActiveInfo* WebGL2RenderingContextBase::getTransformFeedbackVarying(WebGLProgram* program, GLuint index)
 {
     if (isContextLost() || !validateWebGLObject("getTransformFeedbackVarying", program))
         return nullptr;
 
     notImplemented();
     return nullptr;
 }
 
 void WebGL2RenderingContextBase::pauseTransformFeedback()
 {
@@ skipping 156 matching lines @@
 }
 
 void WebGL2RenderingContextBase::uniformBlockBinding(WebGLProgram* program, GLuint uniformBlockIndex, GLuint uniformBlockBinding)
 {
     if (isContextLost() || !validateWebGLObject("uniformBlockBinding", program))
         return;
 
     webContext()->uniformBlockBinding(objectOrZero(program), uniformBlockIndex, uniformBlockBinding);
 }
 
-PassRefPtrWillBeRawPtr<WebGLVertexArrayObject> WebGL2RenderingContextBase::createVertexArray()
+WebGLVertexArrayObject* WebGL2RenderingContextBase::createVertexArray()
 {
     if (isContextLost())
         return nullptr;
 
-    RefPtrWillBeRawPtr<WebGLVertexArrayObject> o = WebGLVertexArrayObject::create(this, WebGLVertexArrayObjectBase::VaoTypeUser);
-    addContextObject(o.get());
-    return o.release();
+    WebGLVertexArrayObject* o = 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 85 matching lines @@
 {
     if (isContextLost())
         return ScriptValue::createNull(scriptState);
     switch (pname) {
     case GL_SHADING_LANGUAGE_VERSION:
         return WebGLAny(scriptState, "WebGL GLSL ES 3.00 (" + String(webContext()->getString(GL_SHADING_LANGUAGE_VERSION)) + ")");
     case GL_VERSION:
         return WebGLAny(scriptState, "WebGL 2.0 (" + String(webContext()->getString(GL_VERSION)) + ")");
 
     case GL_COPY_READ_BUFFER_BINDING:
-        return WebGLAny(scriptState, PassRefPtrWillBeRawPtr<WebGLObject>(m_boundCopyReadBuffer.get()));
+        return WebGLAny(scriptState, m_boundCopyReadBuffer.get());
     case GL_COPY_WRITE_BUFFER_BINDING:
-        return WebGLAny(scriptState, PassRefPtrWillBeRawPtr<WebGLObject>(m_boundCopyWriteBuffer.get()));
+        return WebGLAny(scriptState, m_boundCopyWriteBuffer.get());
     case GL_DRAW_FRAMEBUFFER_BINDING:
-        return WebGLAny(scriptState, PassRefPtrWillBeRawPtr<WebGLObject>(m_framebufferBinding.get()));
+        return WebGLAny(scriptState, m_framebufferBinding.get());
     case GL_FRAGMENT_SHADER_DERIVATIVE_HINT:
         return getUnsignedIntParameter(scriptState, pname);
     case GL_MAX_3D_TEXTURE_SIZE:
         return getIntParameter(scriptState, pname);
     case GL_MAX_ARRAY_TEXTURE_LAYERS:
         return getIntParameter(scriptState, pname);
     case GC3D_MAX_CLIENT_WAIT_TIMEOUT_WEBGL:
         return WebGLAny(scriptState, 0u);
     case GL_MAX_COLOR_ATTACHMENTS:
         return getIntParameter(scriptState, pname);
@@ skipping 45 matching lines @@
         return getIntParameter(scriptState, pname);
     case GL_MIN_PROGRAM_TEXEL_OFFSET:
         return getIntParameter(scriptState, pname);
     case GL_PACK_ROW_LENGTH:
         return getIntParameter(scriptState, pname);
     case GL_PACK_SKIP_PIXELS:
         return getIntParameter(scriptState, pname);
     case GL_PACK_SKIP_ROWS:
         return getIntParameter(scriptState, pname);
     case GL_PIXEL_PACK_BUFFER_BINDING:
-        return WebGLAny(scriptState, PassRefPtrWillBeRawPtr<WebGLObject>(m_boundPixelPackBuffer.get()));
+        return WebGLAny(scriptState, m_boundPixelPackBuffer.get());
     case GL_PIXEL_UNPACK_BUFFER_BINDING:
-        return WebGLAny(scriptState, PassRefPtrWillBeRawPtr<WebGLObject>(m_boundPixelUnpackBuffer.get()));
+        return WebGLAny(scriptState, m_boundPixelUnpackBuffer.get());
     case GL_RASTERIZER_DISCARD:
         return getBooleanParameter(scriptState, pname);
     case GL_READ_BUFFER:
         {
             GLenum value = 0;
             if (!isContextLost()) {
                 WebGLFramebuffer* readFramebufferBinding = getFramebufferBinding(GL_READ_FRAMEBUFFER);
                 if (!readFramebufferBinding)
                     value = m_readBufferOfDefaultFramebuffer;
                 else
                     value = readFramebufferBinding->getReadBuffer();
             }
             return WebGLAny(scriptState, value);
         }
     case GL_READ_FRAMEBUFFER_BINDING:
-        return WebGLAny(scriptState, PassRefPtrWillBeRawPtr<WebGLObject>(m_readFramebufferBinding.get()));
+        return WebGLAny(scriptState, m_readFramebufferBinding.get());
     case GL_SAMPLE_ALPHA_TO_COVERAGE:
         return getBooleanParameter(scriptState, pname);
     case GL_SAMPLE_COVERAGE:
         return getBooleanParameter(scriptState, pname);
     case GL_SAMPLER_BINDING:
-        return WebGLAny(scriptState, PassRefPtrWillBeRawPtr<WebGLObject>(m_samplerUnits[m_activeTextureUnit].get()));
+        return WebGLAny(scriptState, m_samplerUnits[m_activeTextureUnit].get());
     case GL_TEXTURE_BINDING_2D_ARRAY:
-        return WebGLAny(scriptState, PassRefPtrWillBeRawPtr<WebGLObject>(m_textureUnits[m_activeTextureUnit].m_texture2DArrayBinding.get()));
+        return WebGLAny(scriptState, m_textureUnits[m_activeTextureUnit].m_texture2DArrayBinding.get());
     case GL_TEXTURE_BINDING_3D:
-        return WebGLAny(scriptState, PassRefPtrWillBeRawPtr<WebGLObject>(m_textureUnits[m_activeTextureUnit].m_texture3DBinding.get()));
+        return WebGLAny(scriptState, m_textureUnits[m_activeTextureUnit].m_texture3DBinding.get());
     case GL_TRANSFORM_FEEDBACK_ACTIVE:
         return getBooleanParameter(scriptState, pname);
     case GL_TRANSFORM_FEEDBACK_BUFFER_BINDING:
-        return WebGLAny(scriptState, PassRefPtrWillBeRawPtr<WebGLObject>(m_boundTransformFeedbackBuffer.get()));
+        return WebGLAny(scriptState, m_boundTransformFeedbackBuffer.get());
     case GL_TRANSFORM_FEEDBACK_BINDING:
-        return WebGLAny(scriptState, PassRefPtrWillBeRawPtr<WebGLObject>(m_transformFeedbackBinding.get()));
+        return WebGLAny(scriptState, m_transformFeedbackBinding.get());
     case GL_TRANSFORM_FEEDBACK_PAUSED:
         return getBooleanParameter(scriptState, pname);
     case GL_UNIFORM_BUFFER_BINDING:
-        return WebGLAny(scriptState, PassRefPtrWillBeRawPtr<WebGLObject>(m_boundUniformBuffer.get()));
+        return WebGLAny(scriptState, m_boundUniformBuffer.get());
     case GL_UNIFORM_BUFFER_OFFSET_ALIGNMENT:
         return getIntParameter(scriptState, pname);
     case GL_UNPACK_IMAGE_HEIGHT:
         return getIntParameter(scriptState, pname);
     case GL_UNPACK_ROW_LENGTH:
         return getIntParameter(scriptState, pname);
     case GL_UNPACK_SKIP_IMAGES:
         return getBooleanParameter(scriptState, pname);
     case GL_UNPACK_SKIP_PIXELS:
         return getBooleanParameter(scriptState, pname);
@@ skipping 282 matching lines @@
         }
         ASSERT(attachmentObject->isTexture() || attachmentObject->isRenderbuffer());
         if (attachmentObject->isTexture())
             return WebGLAny(scriptState, GL_TEXTURE);
         if (attachmentObject->isRenderbuffer())
             return WebGLAny(scriptState, GL_RENDERBUFFER);
         break;
     case GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME:
         if (!attachmentObject)
             break;
-        return WebGLAny(scriptState, PassRefPtrWillBeRawPtr<WebGLObject>(attachmentObject));
+        return WebGLAny(scriptState, attachmentObject);
     case GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE:
     case GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER:
     case GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL:
         if (!attachmentObject || !attachmentObject->isTexture())
             break;
     case GL_FRAMEBUFFER_ATTACHMENT_RED_SIZE:
     case GL_FRAMEBUFFER_ATTACHMENT_GREEN_SIZE:
     case GL_FRAMEBUFFER_ATTACHMENT_BLUE_SIZE:
     case GL_FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE:
     case GL_FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE:
@@ skipping 102 matching lines @@
     default:
         return WebGLRenderingContextBase::getTexParameter(scriptState, target, pname);
     }
 }
 
 WebGLBuffer* WebGL2RenderingContextBase::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;
     case GL_COPY_READ_BUFFER:
         buffer = m_boundCopyReadBuffer.get();
         break;
     case GL_COPY_WRITE_BUFFER:
         buffer = m_boundCopyWriteBuffer.get();
         break;
@@ skipping 47 matching lines @@
 GLenum WebGL2RenderingContextBase::boundFramebufferColorFormat()
 {
     if (m_readFramebufferBinding && m_readFramebufferBinding->object())
         return m_readFramebufferBinding->colorBufferFormat();
     if (m_requestedAttributes.alpha())
         return GL_RGBA;
     return GL_RGB;
 }
 
 } // namespace blink