[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 PassRefPtrWillBeRawPtr<WebGLFramebuffer::WebGLAttachment> create(WebGLRenderbuffer*);
+    static 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;
 
-    RefPtrWillBeMember<WebGLRenderbuffer> m_renderbuffer;
+    Member<WebGLRenderbuffer> m_renderbuffer;
 };
 
-PassRefPtrWillBeRawPtr<WebGLFramebuffer::WebGLAttachment> WebGLRenderbufferAttachment::create(WebGLRenderbuffer* renderbuffer)
+WebGLFramebuffer::WebGLAttachment* WebGLRenderbufferAttachment::create(WebGLRenderbuffer* renderbuffer)
 {
-    return adoptRefWillBeNoop(new WebGLRenderbufferAttachment(renderbuffer));
+    return 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 PassRefPtrWillBeRawPtr<WebGLFramebuffer::WebGLAttachment> create(WebGLTexture*, GLenum target, GLint level);
+    static 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;
 
-    RefPtrWillBeMember<WebGLTexture> m_texture;
+    Member<WebGLTexture> m_texture;
     GLenum m_target;
     GLint m_level;
 };
 
-PassRefPtrWillBeRawPtr<WebGLFramebuffer::WebGLAttachment> WebGLTextureAttachment::create(WebGLTexture* texture, GLenum target, GLint level)
+WebGLFramebuffer::WebGLAttachment* WebGLTextureAttachment::create(WebGLTexture* texture, GLenum target, GLint level)
 {
-    return adoptRefWillBeNoop(new WebGLTextureAttachment(texture, target, level));
+    return 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()
 {
 }
 
-PassRefPtrWillBeRawPtr<WebGLFramebuffer> WebGLFramebuffer::create(WebGLRenderingContextBase* ctx)
+WebGLFramebuffer* WebGLFramebuffer::create(WebGLRenderingContextBase* ctx)
 {
-    return adoptRefWillBeNoop(new WebGLFramebuffer(ctx));
+    return new WebGLFramebuffer(ctx);
 }
 
 WebGLFramebuffer::WebGLFramebuffer(WebGLRenderingContextBase* ctx)
     : WebGLContextObject(ctx)
     , m_object(ctx->webContext()->createFramebuffer())
     , m_hasEverBeenBound(false)
     , m_readBuffer(GL_COLOR_ATTACHMENT0)
 {
 }
 
 WebGLFramebuffer::~WebGLFramebuffer()
 {
-    // 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.
+    // Delete the platform framebuffer resource.
+    // When the framebuffer object and the WebGLRenderingContextBase object
+    // which is registered with are both finalized, the framebuffer object isn't detached.
+    // Thus we detach() it here.
     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 223 matching lines @@
 {
 #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);

[haraken, 2015/08/05 04:12:19]

I guess this is an existing bug of oilpan builds. onDetached()s for the
attachments need to be called if the deleteObjectImpl() is called from other
than WebGLFramebuffer's destructor.

Specifically, we need to change the code to:

if (m_attachments) {
  for (const auto& attachment : m_attachments)
    attachment.value->onDetached(context3d);
}

without having the #if !ENABLE(OILPAN). And we need to clear m_attachments in
WebGLFramebuffer's destructor.

[peria, 2015/08/06 05:47:00]

Done.

 #endif
 
     context3d->deleteFramebuffer(m_object);
     m_object = 0;
 }
 
 bool WebGLFramebuffer::isBound(GLenum target) const
 {
     return (context()->getFramebufferBinding(target) == this);
 }
@@ skipping 52 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);
 }
 
 }