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

Source/modules/webgl/WebGLFramebuffer.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 20 matching lines @@
 #include "modules/webgl/WebGLRenderingContextBase.h"
 #include "modules/webgl/WebGLTexture.h"
 #include "platform/NotImplemented.h"
 
 namespace blink {
 
 namespace {
 
 class WebGLRenderbufferAttachment final : public WebGLFramebuffer::WebGLAttachment {
 public:
-    static WebGLFramebuffer::WebGLAttachment* create(WebGLRenderbuffer*);
+    static PassRefPtrWillBeRawPtr<WebGLFramebuffer::WebGLAttachment> create(WebGLRenderbuffer*);
 
     DECLARE_VIRTUAL_TRACE();
 
 private:
     explicit WebGLRenderbufferAttachment(WebGLRenderbuffer*);
     WebGLRenderbufferAttachment() { }
 
     GLsizei width() const override;
     GLsizei height() const override;
     GLenum format() const override;
     GLenum type() const override;
     WebGLSharedObject* object() const override;
     bool isSharedObject(WebGLSharedObject*) const override;
     bool valid() const override;
     void onDetached(WebGraphicsContext3D*) override;
     void attach(WebGraphicsContext3D*, GLenum target, GLenum attachment) override;
     void unattach(WebGraphicsContext3D*, GLenum target, GLenum attachment) override;
 
-    Member<WebGLRenderbuffer> m_renderbuffer;
+    RefPtrWillBeMember<WebGLRenderbuffer> m_renderbuffer;
 };
 
-WebGLFramebuffer::WebGLAttachment* WebGLRenderbufferAttachment::create(WebGLRenderbuffer* renderbuffer)
+PassRefPtrWillBeRawPtr<WebGLFramebuffer::WebGLAttachment> WebGLRenderbufferAttachment::create(WebGLRenderbuffer* renderbuffer)
 {
-    return new WebGLRenderbufferAttachment(renderbuffer);
+    return adoptRefWillBeNoop(new WebGLRenderbufferAttachment(renderbuffer));
 }
 
 DEFINE_TRACE(WebGLRenderbufferAttachment)
 {
     visitor->trace(m_renderbuffer);
     WebGLFramebuffer::WebGLAttachment::trace(visitor);
 }
 
 WebGLRenderbufferAttachment::WebGLRenderbufferAttachment(WebGLRenderbuffer* renderbuffer)
     : m_renderbuffer(renderbuffer)
@@ skipping 57 matching lines @@
     if (attachment == GL_DEPTH_STENCIL_ATTACHMENT) {
         context->framebufferRenderbuffer(target, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER, 0);
         context->framebufferRenderbuffer(target, GL_STENCIL_ATTACHMENT, GL_RENDERBUFFER, 0);
     } else {
         context->framebufferRenderbuffer(target, attachment, GL_RENDERBUFFER, 0);
     }
 }
 
 GLenum WebGLRenderbufferAttachment::type() const
 {
-    notImplemented();
     return 0;
 }
 
 class WebGLTextureAttachment final : public WebGLFramebuffer::WebGLAttachment {
 public:
-    static WebGLFramebuffer::WebGLAttachment* create(WebGLTexture*, GLenum target, GLint level);
+    static PassRefPtrWillBeRawPtr<WebGLFramebuffer::WebGLAttachment> create(WebGLTexture*, GLenum target, GLint level);
 
     DECLARE_VIRTUAL_TRACE();
 
 private:
     WebGLTextureAttachment(WebGLTexture*, GLenum target, GLint level);
     WebGLTextureAttachment() { }
 
     GLsizei width() const override;
     GLsizei height() const override;
     GLenum format() const override;
     GLenum type() const override;
     WebGLSharedObject* object() const override;
     bool isSharedObject(WebGLSharedObject*) const override;
     bool valid() const override;
     void onDetached(WebGraphicsContext3D*) override;
     void attach(WebGraphicsContext3D*, GLenum target, GLenum attachment) override;
     void unattach(WebGraphicsContext3D*, GLenum target, GLenum attachment) override;
 
-    Member<WebGLTexture> m_texture;
+    RefPtrWillBeMember<WebGLTexture> m_texture;
     GLenum m_target;
     GLint m_level;
 };
 
-WebGLFramebuffer::WebGLAttachment* WebGLTextureAttachment::create(WebGLTexture* texture, GLenum target, GLint level)
+PassRefPtrWillBeRawPtr<WebGLFramebuffer::WebGLAttachment> WebGLTextureAttachment::create(WebGLTexture* texture, GLenum target, GLint level)
 {
-    return new WebGLTextureAttachment(texture, target, level);
+    return adoptRefWillBeNoop(new WebGLTextureAttachment(texture, target, level));
 }
 
 DEFINE_TRACE(WebGLTextureAttachment)
 {
     visitor->trace(m_texture);
     WebGLFramebuffer::WebGLAttachment::trace(visitor);
 }
 
 WebGLTextureAttachment::WebGLTextureAttachment(WebGLTexture* texture, GLenum target, GLint level)
     : m_texture(texture)
@@ skipping 132 matching lines @@
 } // anonymous namespace
 
 WebGLFramebuffer::WebGLAttachment::WebGLAttachment()
 {
 }
 
 WebGLFramebuffer::WebGLAttachment::~WebGLAttachment()
 {
 }
 
-WebGLFramebuffer* WebGLFramebuffer::create(WebGLRenderingContextBase* ctx)
+PassRefPtrWillBeRawPtr<WebGLFramebuffer> WebGLFramebuffer::create(WebGLRenderingContextBase* ctx)
 {
-    return new WebGLFramebuffer(ctx);
+    return adoptRefWillBeNoop(new WebGLFramebuffer(ctx));
 }
 
 WebGLFramebuffer::WebGLFramebuffer(WebGLRenderingContextBase* ctx)
     : WebGLContextObject(ctx)
     , m_object(ctx->webContext()->createFramebuffer())
     , m_hasEverBeenBound(false)
     , m_readBuffer(GL_COLOR_ATTACHMENT0)
 {
 }
 
 WebGLFramebuffer::~WebGLFramebuffer()
 {
-    // Attachments in |m_attachments| will be deleted from other places, so we
-    // clear it to avoid deleting those attachments in detachAndDeleteObject().
-    m_attachments.clear();
-
-    // See the comment in WebGLObject::detachAndDeleteObject().
+    // Delete the platform framebuffer resource. Explicit detachment
+    // is for the benefit of Oilpan, where the framebuffer object
+    // isn't detached when it and the WebGLRenderingContextBase object
+    // it is registered with are both finalized. Without Oilpan, the
+    // object will have been detached.
+    //
+    // To keep the code regular, the trivial detach()ment is always
+    // performed.
     detachAndDeleteObject();
 }
 
 void WebGLFramebuffer::setAttachmentForBoundFramebuffer(GLenum target, GLenum attachment, GLenum texTarget, WebGLTexture* texture, GLint level)
 {
     ASSERT(isBound(target));
     removeAttachmentFromBoundFramebuffer(target, attachment);
     if (!m_object)
         return;
     if (texture && texture->object()) {
@@ skipping 214 matching lines @@
 bool WebGLFramebuffer::hasStencilBuffer() const
 {
     WebGLAttachment* attachment = getAttachment(GL_STENCIL_ATTACHMENT);
     if (!attachment)
         attachment = getAttachment(GL_DEPTH_STENCIL_ATTACHMENT);
     return attachment && attachment->valid();
 }
 
 void WebGLFramebuffer::deleteObjectImpl(WebGraphicsContext3D* context3d)
 {
-    // Both the AttachmentMap and its WebGLAttachment objects are GCed
-    // objects and cannot be accessed, as they may have been finalized
+#if !ENABLE(OILPAN)
+    // With Oilpan, both the AttachmentMap and its WebGLAttachment objects are
+    // GCed objects and cannot be accessed, as they may have been finalized
     // already during the same GC sweep.
+    //
+    // The WebGLAttachment-derived classes instead handle detachment
+    // on their own when finalizing, so the explicit notification is
+    // not needed.
     for (const auto& attachment : m_attachments)
         attachment.value->onDetached(context3d);
+#endif
 
     context3d->deleteFramebuffer(m_object);
     m_object = 0;
 }
 
 bool WebGLFramebuffer::isBound(GLenum target) const
 {
     return (context()->getFramebufferBinding(target) == this);
 }
 
@@ skipping 51 matching lines @@
         return false;
     if (format)
         *format = image->format();
     if (type)
         *type = image->type();
     return true;
 }
 
 DEFINE_TRACE(WebGLFramebuffer)
 {
+#if ENABLE(OILPAN)
     visitor->trace(m_attachments);
+#endif
     WebGLContextObject::trace(visitor);
 }
 
 }