Use nullptr_t for RefPtr, PassRefPtr and RawPtr.

Source/core/html/canvas/WebGLRenderingContext.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 509 matching lines @@
         return nullptr;
     }
 
     return renderingContext.release();
 }
 
 WebGLRenderingContext::WebGLRenderingContext(HTMLCanvasElement* passedCanvas, PassOwnPtr<blink::WebGraphicsContext3D> context, WebGLContextAttributes* requestedAttributes)
     : CanvasRenderingContext(passedCanvas)
     , ActiveDOMObject(&passedCanvas->document())
     , m_context(context)
-    , m_drawingBuffer(0)
+    , m_drawingBuffer(nullptr)
     , m_dispatchContextLostEventTimer(this, &WebGLRenderingContext::dispatchContextLostEvent)
     , m_restoreAllowed(false)
     , m_restoreTimer(this, &WebGLRenderingContext::maybeRestoreContext)
     , m_generatedImageCache(4)
     , m_contextLost(false)
     , m_contextLostMode(SyntheticLostContext)
     , m_requestedAttributes(requestedAttributes->clone())
     , m_synthesizedErrorsToConsole(true)
     , m_numGLErrorsToConsoleAllowed(maxGLErrorsAllowedToConsole)
     , m_multisamplingAllowed(false)
@@ skipping 54 matching lines @@
 {
     ASSERT(!isContextLost());
     m_needsUpdate = true;
     m_markedCanvasDirty = false;
     m_activeTextureUnit = 0;
     m_packAlignment = 4;
     m_unpackAlignment = 4;
     m_unpackFlipY = false;
     m_unpackPremultiplyAlpha = false;
     m_unpackColorspaceConversion = GC3D_BROWSER_DEFAULT_WEBGL;
-    m_boundArrayBuffer = 0;
-    m_currentProgram = 0;
-    m_framebufferBinding = 0;
-    m_renderbufferBinding = 0;
+    m_boundArrayBuffer = nullptr;
+    m_currentProgram = nullptr;
+    m_framebufferBinding = nullptr;
+    m_renderbufferBinding = nullptr;
     m_depthMask = true;
     m_stencilEnabled = false;
     m_stencilMask = 0xFFFFFFFF;
     m_stencilMaskBack = 0xFFFFFFFF;
     m_stencilFuncRef = 0;
     m_stencilFuncRefBack = 0;
     m_stencilFuncMask = 0xFFFFFFFF;
     m_stencilFuncMaskBack = 0xFFFFFFFF;
     m_layerCleared = false;
     m_numGLErrorsToConsoleAllowed = maxGLErrorsAllowedToConsole;
@@ skipping 90 matching lines @@
 
 void WebGLRenderingContext::removeAllCompressedTextureFormats()
 {
     m_compressedTextureFormats.clear();
 }
 
 WebGLRenderingContext::~WebGLRenderingContext()
 {
     // 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 = 0;
-    m_defaultVertexArrayObject = 0;
-    m_boundVertexArrayObject = 0;
-    m_vertexAttrib0Buffer = 0;
-    m_currentProgram = 0;
-    m_framebufferBinding = 0;
-    m_renderbufferBinding = 0;
+    m_boundArrayBuffer = nullptr;
+    m_defaultVertexArrayObject = nullptr;
+    m_boundVertexArrayObject = nullptr;
+    m_vertexAttrib0Buffer = nullptr;
+    m_currentProgram = nullptr;
+    m_framebufferBinding = nullptr;
+    m_renderbufferBinding = nullptr;
 
     for (size_t i = 0; i < m_textureUnits.size(); ++i) {
-      m_textureUnits[i].m_texture2DBinding = 0;
-      m_textureUnits[i].m_textureCubeMapBinding = 0;
+        m_textureUnits[i].m_texture2DBinding = nullptr;
+        m_textureUnits[i].m_textureCubeMapBinding = nullptr;
     }
 
-    m_blackTexture2D = 0;
-    m_blackTextureCubeMap = 0;
+    m_blackTexture2D = nullptr;
+    m_blackTextureCubeMap = nullptr;
 
     detachAndRemoveAllObjects();
 
     // release all extensions
     for (size_t i = 0; i < m_extensions.size(); ++i)
         delete m_extensions[i];
 
     // Context must be removed from the group prior to the destruction of the
     // WebGraphicsContext3D, otherwise shared objects may not be properly deleted.
     m_contextGroup->removeContext(this);
@@ skipping 155 matching lines @@
 
     if (m_framebufferBinding)
         m_context->bindFramebuffer(GL_FRAMEBUFFER, objectOrZero(m_framebufferBinding.get()));
     else
         m_drawingBuffer->bind();
 }
 
 PassRefPtr<ImageData> WebGLRenderingContext::paintRenderingResultsToImageData()
 {
     if (isContextLost())
-        return 0;
+        return nullptr;
 
     clearIfComposited();
     m_drawingBuffer->commit();
     int width, height;
     RefPtr<Uint8ClampedArray> imageDataPixels = m_drawingBuffer->paintRenderingResultsToImageData(width, height);
     if (!imageDataPixels)
-        return 0;
+        return nullptr;
 
     if (m_framebufferBinding)
         m_context->bindFramebuffer(GL_FRAMEBUFFER, objectOrZero(m_framebufferBinding.get()));
     else
         m_drawingBuffer->bind();
 
     return ImageData::create(IntSize(width, height), imageDataPixels);
 }
 
 void WebGLRenderingContext::reshape(int width, int height)
@@ skipping 587 matching lines @@
         return;
     }
     clearIfComposited();
     ScopedDrawingBufferBinder binder(m_drawingBuffer.get(), m_framebufferBinding.get());
     m_context->copyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height);
 }
 
 PassRefPtr<WebGLBuffer> WebGLRenderingContext::createBuffer()
 {
     if (isContextLost())
-        return 0;
+        return nullptr;
     RefPtr<WebGLBuffer> o = WebGLBuffer::create(this);
     addSharedObject(o.get());
     return o;
 }
 
 PassRefPtr<WebGLFramebuffer> WebGLRenderingContext::createFramebuffer()
 {
     if (isContextLost())
-        return 0;
+        return nullptr;
     RefPtr<WebGLFramebuffer> o = WebGLFramebuffer::create(this);
     addContextObject(o.get());
     return o;
 }
 
 PassRefPtr<WebGLTexture> WebGLRenderingContext::createTexture()
 {
     if (isContextLost())
-        return 0;
+        return nullptr;
     RefPtr<WebGLTexture> o = WebGLTexture::create(this);
     addSharedObject(o.get());
     return o;
 }
 
 PassRefPtr<WebGLProgram> WebGLRenderingContext::createProgram()
 {
     if (isContextLost())
-        return 0;
+        return nullptr;
     RefPtr<WebGLProgram> o = WebGLProgram::create(this);
     addSharedObject(o.get());
     return o;
 }
 
 PassRefPtr<WebGLRenderbuffer> WebGLRenderingContext::createRenderbuffer()
 {
     if (isContextLost())
-        return 0;
+        return nullptr;
     RefPtr<WebGLRenderbuffer> o = WebGLRenderbuffer::create(this);
     addSharedObject(o.get());
     return o;
 }
 
 WebGLRenderbuffer* WebGLRenderingContext::ensureEmulatedStencilBuffer(GLenum target, WebGLRenderbuffer* renderbuffer)
 {
     if (isContextLost())
         return 0;
     if (!renderbuffer->emulatedStencilBuffer()) {
         renderbuffer->setEmulatedStencilBuffer(createRenderbuffer());
         m_context->bindRenderbuffer(target, objectOrZero(renderbuffer->emulatedStencilBuffer()));
         m_context->bindRenderbuffer(target, objectOrZero(m_renderbufferBinding.get()));
     }
     return renderbuffer->emulatedStencilBuffer();
 }
 
 PassRefPtr<WebGLShader> WebGLRenderingContext::createShader(GLenum type)
 {
     if (isContextLost())
-        return 0;
+        return nullptr;
     if (type != GL_VERTEX_SHADER && type != GL_FRAGMENT_SHADER) {
         synthesizeGLError(GL_INVALID_ENUM, "createShader", "invalid shader type");
-        return 0;
+        return nullptr;
     }
 
     RefPtr<WebGLShader> o = WebGLShader::create(this, type);
     addSharedObject(o.get());
     return o;
 }
 
 void WebGLRenderingContext::cullFace(GLenum mode)
 {
     if (isContextLost())
@@ skipping 24 matching lines @@
         object->deleteObject(m_context.get());
     }
     return true;
 }
 
 void WebGLRenderingContext::deleteBuffer(WebGLBuffer* buffer)
 {
     if (!deleteObject(buffer))
         return;
     if (m_boundArrayBuffer == buffer)
-        m_boundArrayBuffer = 0;
+        m_boundArrayBuffer = nullptr;
 
     m_boundVertexArrayObject->unbindBuffer(buffer);
 }
 
 void WebGLRenderingContext::deleteFramebuffer(WebGLFramebuffer* framebuffer)
 {
     if (!deleteObject(framebuffer))
         return;
     if (framebuffer == m_framebufferBinding) {
-        m_framebufferBinding = 0;
+        m_framebufferBinding = nullptr;
         m_drawingBuffer->setFramebufferBinding(0);
         // Have to call bindFramebuffer here to bind back to internal fbo.
         m_drawingBuffer->bind();
     }
 }
 
 void WebGLRenderingContext::deleteProgram(WebGLProgram* program)
 {
     deleteObject(program);
     // We don't reset m_currentProgram to 0 here because the deletion of the
     // current program is delayed.
 }
 
 void WebGLRenderingContext::deleteRenderbuffer(WebGLRenderbuffer* renderbuffer)
 {
     if (!deleteObject(renderbuffer))
         return;
     if (renderbuffer == m_renderbufferBinding)
-        m_renderbufferBinding = 0;
+        m_renderbufferBinding = nullptr;
     if (m_framebufferBinding)
         m_framebufferBinding->removeAttachmentFromBoundFramebuffer(renderbuffer);
 }
 
 void WebGLRenderingContext::deleteShader(WebGLShader* shader)
 {
     deleteObject(shader);
 }
 
 void WebGLRenderingContext::deleteTexture(WebGLTexture* texture)
 {
     if (!deleteObject(texture))
         return;
 
     int maxBoundTextureIndex = -1;
     for (size_t i = 0; i < m_onePlusMaxNonDefaultTextureUnit; ++i) {
         if (texture == m_textureUnits[i].m_texture2DBinding) {
-            m_textureUnits[i].m_texture2DBinding = 0;
+            m_textureUnits[i].m_texture2DBinding = nullptr;
             maxBoundTextureIndex = i;
             if (!i)
                 m_drawingBuffer->setTexture2DBinding(0);
         }
         if (texture == m_textureUnits[i].m_textureCubeMapBinding) {
-            m_textureUnits[i].m_textureCubeMapBinding = 0;
+            m_textureUnits[i].m_textureCubeMapBinding = nullptr;
             maxBoundTextureIndex = i;
         }
     }
     if (m_framebufferBinding)
         m_framebufferBinding->removeAttachmentFromBoundFramebuffer(texture);
 
     // If the deleted was bound to the the current maximum index, trace backwards to find the new max texture index
     if (m_onePlusMaxNonDefaultTextureUnit == static_cast<unsigned long>(maxBoundTextureIndex + 1)) {
         findNewMaxNonDefaultTextureUnit();
     }
@@ skipping 335 matching lines @@
 #if OS(MACOSX)
     if (needToResetMinFilter)
         m_context->texParameteri(target, GL_TEXTURE_MIN_FILTER, tex->getMinFilter());
 #endif
     tex->generateMipmapLevelInfo();
 }
 
 PassRefPtr<WebGLActiveInfo> WebGLRenderingContext::getActiveAttrib(WebGLProgram* program, GLuint index)
 {
     if (isContextLost() || !validateWebGLObject("getActiveAttrib", program))
-        return 0;
+        return nullptr;
     blink::WebGraphicsContext3D::ActiveInfo info;
     if (!m_context->getActiveAttrib(objectOrZero(program), index, info))
-        return 0;
+        return nullptr;
     return WebGLActiveInfo::create(info.name, info.type, info.size);
 }
 
 PassRefPtr<WebGLActiveInfo> WebGLRenderingContext::getActiveUniform(WebGLProgram* program, GLuint index)
 {
     if (isContextLost() || !validateWebGLObject("getActiveUniform", program))
-        return 0;
+        return nullptr;
     blink::WebGraphicsContext3D::ActiveInfo info;
     if (!m_context->getActiveUniform(objectOrZero(program), index, info))
-        return 0;
+        return nullptr;
     return WebGLActiveInfo::create(info.name, info.type, info.size);
 }
 
 bool WebGLRenderingContext::getAttachedShaders(WebGLProgram* program, Vector<RefPtr<WebGLShader> >& shaderObjects)
 {
     shaderObjects.clear();
     if (isContextLost() || !validateWebGLObject("getAttachedShaders", program))
         return false;
 
     const GLenum shaderType[] = {
@@ skipping 42 matching lines @@
     GLint value = 0;
     m_context->getBufferParameteriv(target, pname, &value);
     if (pname == GL_BUFFER_SIZE)
         return WebGLGetInfo(value);
     return WebGLGetInfo(static_cast<unsigned>(value));
 }
 
 PassRefPtr<WebGLContextAttributes> WebGLRenderingContext::getContextAttributes()
 {
     if (isContextLost())
-        return 0;
+        return nullptr;
     // We always need to return a new WebGLContextAttributes object to
     // prevent the user from mutating any cached version.
     blink::WebGraphicsContext3D::Attributes attrs = m_context->getContextAttributes();
     RefPtr<WebGLContextAttributes> attributes = m_requestedAttributes->clone();
     // Some requested attributes may not be honored, so we need to query the underlying
     // context/drawing buffer and adjust accordingly.
     if (m_requestedAttributes->depth() && !attrs.depth)
         attributes->setDepth(false);
     if (m_requestedAttributes->stencil() && !attrs.stencil)
         attributes->setStencil(false);
@@ skipping 25 matching lines @@
         if (equalIgnoringCase(prefixedName, name)) {
             return true;
         }
     }
     return false;
 }
 
 PassRefPtr<WebGLExtension> WebGLRenderingContext::getExtension(const String& name)
 {
     if (isContextLost())
-        return 0;
+        return nullptr;
 
     for (size_t i = 0; i < m_extensions.size(); ++i) {
         ExtensionTracker* tracker = m_extensions[i];
         if (tracker->matchesNameWithPrefixes(name)) {
             if (tracker->webglDebugRendererInfo() && !allowWebGLDebugRendererInfo())
-                return 0;
+                return nullptr;
             if (tracker->privileged() && !allowPrivilegedExtensions())
-                return 0;
+                return nullptr;
             if (tracker->draft() && !RuntimeEnabledFeatures::webGLDraftExtensionsEnabled())
-                return 0;
+                return nullptr;
             if (!tracker->supported(this))
-                return 0;
+                return nullptr;
             return tracker->getExtension(this);
         }
     }
 
-    return 0;
+    return nullptr;
 }
 
 WebGLGetInfo WebGLRenderingContext::getFramebufferAttachmentParameter(GLenum target, GLenum attachment, GLenum pname)
 {
     if (isContextLost() || !validateFramebufferFuncParameters("getFramebufferAttachmentParameter", target, attachment))
         return WebGLGetInfo();
 
     if (!m_framebufferBinding || !m_framebufferBinding->object()) {
         synthesizeGLError(GL_INVALID_OPERATION, "getFramebufferAttachmentParameter", "no framebuffer bound");
         return WebGLGetInfo();
@@ skipping 377 matching lines @@
     if (isContextLost())
         return String();
     if (!validateWebGLObject("getShaderInfoLog", shader))
         return "";
     return ensureNotNull(m_context->getShaderInfoLog(objectOrZero(shader)));
 }
 
 PassRefPtr<WebGLShaderPrecisionFormat> WebGLRenderingContext::getShaderPrecisionFormat(GLenum shaderType, GLenum precisionType)
 {
     if (isContextLost())
-        return 0;
+        return nullptr;
     switch (shaderType) {
     case GL_VERTEX_SHADER:
     case GL_FRAGMENT_SHADER:
         break;
     default:
         synthesizeGLError(GL_INVALID_ENUM, "getShaderPrecisionFormat", "invalid shader type");
-        return 0;
+        return nullptr;
     }
     switch (precisionType) {
     case GL_LOW_FLOAT:
     case GL_MEDIUM_FLOAT:
     case GL_HIGH_FLOAT:
     case GL_LOW_INT:
     case GL_MEDIUM_INT:
     case GL_HIGH_INT:
         break;
     default:
         synthesizeGLError(GL_INVALID_ENUM, "getShaderPrecisionFormat", "invalid precision type");
-        return 0;
+        return nullptr;
     }
 
     GLint range[2] = {0, 0};
     GLint precision = 0;
     m_context->getShaderPrecisionFormat(shaderType, precisionType, range, &precision);
     return WebGLShaderPrecisionFormat::create(range[0], range[1], precision);
 }
 
 String WebGLRenderingContext::getShaderSource(WebGLShader* shader)
 {
@@ skipping 194 matching lines @@
         }
     }
     // If we get here, something went wrong in our unfortunately complex logic above
     synthesizeGLError(GL_INVALID_VALUE, "getUniform", "unknown error");
     return WebGLGetInfo();
 }
 
 PassRefPtr<WebGLUniformLocation> WebGLRenderingContext::getUniformLocation(WebGLProgram* program, const String& name)
 {
     if (isContextLost() || !validateWebGLObject("getUniformLocation", program))
-        return 0;
+        return nullptr;
     if (!validateLocationLength("getUniformLocation", name))
-        return 0;
+        return nullptr;
     if (!validateString("getUniformLocation", name))
-        return 0;
+        return nullptr;
     if (isPrefixReserved(name))
-        return 0;
+        return nullptr;
     if (!program->linkStatus()) {
         synthesizeGLError(GL_INVALID_OPERATION, "getUniformLocation", "program not linked");
-        return 0;
+        return nullptr;
     }
     GLint uniformLocation = m_context->getUniformLocation(objectOrZero(program), name.utf8().data());
     if (uniformLocation == -1)
-        return 0;
+        return nullptr;
     return WebGLUniformLocation::create(program, uniformLocation);
 }
 
 WebGLGetInfo WebGLRenderingContext::getVertexAttrib(GLuint index, GLenum pname)
 {
     if (isContextLost())
         return WebGLGetInfo();
     if (index >= m_maxVertexAttribs) {
         synthesizeGLError(GL_INVALID_VALUE, "getVertexAttrib", "index out of range");
         return WebGLGetInfo();
@@ skipping 539 matching lines @@
 
     return true;
 }
 
 PassRefPtr<Image> WebGLRenderingContext::drawImageIntoBuffer(Image* image, int width, int height)
 {
     IntSize size(width, height);
     ImageBuffer* buf = m_generatedImageCache.imageBuffer(size);
     if (!buf) {
         synthesizeGLError(GL_OUT_OF_MEMORY, "texImage2D", "out of memory");
-        return 0;
+        return nullptr;
     }
 
     IntRect srcRect(IntPoint(), image->size());
     IntRect destRect(0, 0, size.width(), size.height());
     buf->context()->drawImage(image, destRect, srcRect);
     return buf->copyImage(ImageBuffer::fastCopyImageMode());
 }
 
 void WebGLRenderingContext::texImage2D(GLenum target, GLint level, GLenum internalformat,
     GLsizei width, GLsizei height, GLint border,
@@ skipping 91 matching lines @@
     else
         texImage2DImpl(target, level, internalformat, format, type, canvas->copiedImage(), WebGLImageConversion::HtmlDomCanvas, m_unpackFlipY, m_unpackPremultiplyAlpha, exceptionState);
 }
 
 PassRefPtr<Image> WebGLRenderingContext::videoFrameToImage(HTMLVideoElement* video, BackingStoreCopy backingStoreCopy)
 {
     IntSize size(video->videoWidth(), video->videoHeight());
     ImageBuffer* buf = m_generatedImageCache.imageBuffer(size);
     if (!buf) {
         synthesizeGLError(GL_OUT_OF_MEMORY, "texImage2D", "out of memory");
-        return 0;
+        return nullptr;
     }
     IntRect destRect(0, 0, size.width(), size.height());
     // FIXME: Turn this into a GPU-GPU texture copy instead of CPU readback.
     video->paintCurrentFrameInContext(buf->context(), destRect);
     return buf->copyImage(backingStoreCopy);
 }
 
 void WebGLRenderingContext::texImage2D(GLenum target, GLint level, GLenum internalformat,
     GLenum format, GLenum type, HTMLVideoElement* video, ExceptionState& exceptionState)
 {
@@ skipping 2102 matching lines @@
         if (m_textureUnits[i].m_texture2DBinding
             || m_textureUnits[i].m_textureCubeMapBinding) {
             m_onePlusMaxNonDefaultTextureUnit = i + 1;
             return;
         }
     }
     m_onePlusMaxNonDefaultTextureUnit = 0;
 }
 
 } // namespace WebCore