Make WebGL2 objects Oilpan compatible.

Source/core/html/canvas/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 "core/html/canvas/WebGL2RenderingContextBase.h"
 
 #include "bindings/core/v8/WebGLAny.h"
 #include "core/html/HTMLCanvasElement.h"
 #include "core/html/HTMLImageElement.h"
@@ skipping 702 matching lines @@
 }
 
 void WebGL2RenderingContextBase::clearBufferfi(GLenum buffer, GLint drawbuffer, GLfloat depth, GLint stencil)
 {
     if (isContextLost())
         return;
 
     webContext()->clearBufferfi(buffer, drawbuffer, depth, stencil);
 }
 
-PassRefPtr<WebGLQuery> WebGL2RenderingContextBase::createQuery()
+PassRefPtrWillBeRawPtr<WebGLQuery> WebGL2RenderingContextBase::createQuery()
 {
     if (isContextLost())
         return nullptr;
-    RefPtr<WebGLQuery> o = WebGLQuery::create(this);
+    RefPtrWillBeRawPtr<WebGLQuery> o = WebGLQuery::create(this);
     addSharedObject(o.get());
     return o;
 }
 
 void WebGL2RenderingContextBase::deleteQuery(WebGLQuery* query)
 {
     deleteObject(query);
 }
 
 GLboolean WebGL2RenderingContextBase::isQuery(WebGLQuery* query)
@@ skipping 13 matching lines @@
 }
 
 void WebGL2RenderingContextBase::endQuery(GLenum target)
 {
     if (isContextLost())
         return;
 
     webContext()->endQueryEXT(target);
 }
 
-PassRefPtr<WebGLQuery> WebGL2RenderingContextBase::getQuery(GLenum target, GLenum pname)
+PassRefPtrWillBeRawPtr<WebGLQuery> WebGL2RenderingContextBase::getQuery(GLenum target, GLenum pname)
 {
     if (isContextLost())
         return nullptr;
 
     notImplemented();
     return nullptr;
 }
 
 ScriptValue WebGL2RenderingContextBase::getQueryParameter(ScriptState* scriptState, WebGLQuery* query, GLenum pname)
 {
     if (isContextLost() || !validateWebGLObject("getQueryParameter", query))
         return ScriptValue::createNull(scriptState);
 
     notImplemented();
     return ScriptValue::createNull(scriptState);
 }
 
-PassRefPtr<WebGLSampler> WebGL2RenderingContextBase::createSampler()
+PassRefPtrWillBeRawPtr<WebGLSampler> WebGL2RenderingContextBase::createSampler()
 {
     if (isContextLost())
         return nullptr;
-    RefPtr<WebGLSampler> o = WebGLSampler::create(this);
+    RefPtrWillBeRawPtr<WebGLSampler> o = WebGLSampler::create(this);
     addSharedObject(o.get());
     return o;
 }
 
 void WebGL2RenderingContextBase::deleteSampler(WebGLSampler* sampler)
 {
     deleteObject(sampler);
 }
 
 GLboolean WebGL2RenderingContextBase::isSampler(WebGLSampler* sampler)
@@ skipping 52 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);
     }
 }
 
-PassRefPtr<WebGLSync> WebGL2RenderingContextBase::fenceSync(GLenum condition, GLbitfield flags)
+PassRefPtrWillBeRawPtr<WebGLSync> WebGL2RenderingContextBase::fenceSync(GLenum condition, GLbitfield flags)
 {
     if (isContextLost())
         return nullptr;
 
-    RefPtr<WebGLSync> o = WebGLFenceSync::create(this, condition, flags);
+    RefPtrWillBeRawPtr<WebGLSync> o = WebGLFenceSync::create(this, condition, flags);
     addSharedObject(o.get());
     return o.release();
 }
 
 GLboolean WebGL2RenderingContextBase::isSync(WebGLSync* sync)
 {
     if (isContextLost() || !sync)
         return 0;
 
     return webContext()->isSync(sync->object());
@@ skipping 24 matching lines @@
 
 ScriptValue WebGL2RenderingContextBase::getSyncParameter(ScriptState* scriptState, WebGLSync* sync, GLenum pname)
 {
     if (isContextLost() || !validateWebGLObject("getSyncParameter", sync))
         return ScriptValue::createNull(scriptState);
 
     notImplemented();
     return ScriptValue::createNull(scriptState);
 }
 
-PassRefPtr<WebGLTransformFeedback> WebGL2RenderingContextBase::createTransformFeedback()
+PassRefPtrWillBeRawPtr<WebGLTransformFeedback> WebGL2RenderingContextBase::createTransformFeedback()
 {
     if (isContextLost())
         return nullptr;
-    RefPtr<WebGLTransformFeedback> o = WebGLTransformFeedback::create(this);
+    RefPtrWillBeRawPtr<WebGLTransformFeedback> o = WebGLTransformFeedback::create(this);
     addSharedObject(o.get());
     return o;
 }
 
 void WebGL2RenderingContextBase::deleteTransformFeedback(WebGLTransformFeedback* feedback)
 {
     deleteObject(feedback);
 }
 
 GLboolean WebGL2RenderingContextBase::isTransformFeedback(WebGLTransformFeedback* feedback)
@@ skipping 29 matching lines @@
 }
 
 void WebGL2RenderingContextBase::transformFeedbackVaryings(WebGLProgram* program, const Vector<String>& varyings, GLenum bufferMode)
 {
     if (isContextLost() || !validateWebGLObject("transformFeedbackVaryings", program))
         return;
 
     notImplemented();
 }
 
-PassRefPtr<WebGLActiveInfo> WebGL2RenderingContextBase::getTransformFeedbackVarying(WebGLProgram* program, GLuint index)
+PassRefPtrWillBeRawPtr<WebGLActiveInfo> WebGL2RenderingContextBase::getTransformFeedbackVarying(WebGLProgram* program, GLuint index)
 {
     if (isContextLost() || !validateWebGLObject("getTransformFeedbackVarying", program))
         return nullptr;
 
     notImplemented();
     return nullptr;
 }
 
 void WebGL2RenderingContextBase::pauseTransformFeedback()
 {
@@ skipping 118 matching lines @@
 }
 
 void WebGL2RenderingContextBase::uniformBlockBinding(WebGLProgram* program, GLuint uniformBlockIndex, GLuint uniformBlockBinding)
 {
     if (isContextLost() || !validateWebGLObject("uniformBlockBinding", program))
         return;
 
     webContext()->uniformBlockBinding(objectOrZero(program), uniformBlockIndex, uniformBlockBinding);
 }
 
-PassRefPtr<WebGLVertexArrayObjectOES> WebGL2RenderingContextBase::createVertexArray()
+PassRefPtrWillBeRawPtr<WebGLVertexArrayObjectOES> WebGL2RenderingContextBase::createVertexArray()
 {
     if (isContextLost())
         return nullptr;
 
-    RefPtr<WebGLVertexArrayObjectOES> o = WebGLVertexArrayObjectOES::create(this, WebGLVertexArrayObjectOES::VaoTypeUser);
+    RefPtrWillBeRawPtr<WebGLVertexArrayObjectOES> o = WebGLVertexArrayObjectOES::create(this, WebGLVertexArrayObjectOES::VaoTypeUser);
     addContextObject(o.get());
     return o.release();
 }
 
 void WebGL2RenderingContextBase::deleteVertexArray(WebGLVertexArrayObjectOES* vertexArray)
 {
     if (isContextLost() || !vertexArray)
         return;
 
     if (!vertexArray->isDefaultObject() && vertexArray == m_boundVertexArrayObject)
@@ skipping 33 matching lines @@
         setBoundVertexArrayObject(nullptr);
     }
 }
 
 void WebGL2RenderingContextBase::trace(Visitor* visitor)
 {
     WebGLRenderingContextBase::trace(visitor);
 }
 
 } // namespace blink