Remove framebufferRenderbuffer and framebufferTexture* from WGC3D.

third_party/WebKit/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
  *    documentation and/or other materials provided with the distribution.
  *
  * THIS SOFTWARE IS PROVIDED BY APPLE COMPUTER, INC. ``AS IS'' AND ANY
  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE COMPUTER, INC. OR
  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #include "modules/webgl/WebGLFramebuffer.h"
 
+#include "gpu/command_buffer/client/gles2_interface.h"
 #include "modules/webgl/WebGLRenderbuffer.h"
 #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*);
 
     DECLARE_VIRTUAL_TRACE();
 
 private:
     explicit WebGLRenderbufferAttachment(WebGLRenderbuffer*);
     WebGLRenderbufferAttachment() { }
 
     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;
+    void attach(gpu::gles2::GLES2Interface*, GLenum target, GLenum attachment) override;
+    void unattach(gpu::gles2::GLES2Interface*, GLenum target, GLenum attachment) override;
 
     Member<WebGLRenderbuffer> m_renderbuffer;
 };
 
 WebGLFramebuffer::WebGLAttachment* WebGLRenderbufferAttachment::create(WebGLRenderbuffer* renderbuffer)
 {
     return new WebGLRenderbufferAttachment(renderbuffer);
 }
 
 DEFINE_TRACE(WebGLRenderbufferAttachment)
@@ skipping 20 matching lines @@
 bool WebGLRenderbufferAttachment::valid() const
 {
     return m_renderbuffer->object();
 }
 
 void WebGLRenderbufferAttachment::onDetached(WebGraphicsContext3D* context)
 {
     m_renderbuffer->onDetached(context);
 }
 
-void WebGLRenderbufferAttachment::attach(WebGraphicsContext3D* context, GLenum target, GLenum attachment)
+void WebGLRenderbufferAttachment::attach(gpu::gles2::GLES2Interface* gl, GLenum target, GLenum attachment)
 {
     Platform3DObject object = objectOrZero(m_renderbuffer.get());
-    context->framebufferRenderbuffer(target, attachment, GL_RENDERBUFFER, object);
+    gl->FramebufferRenderbuffer(target, attachment, GL_RENDERBUFFER, object);
 }
 
-void WebGLRenderbufferAttachment::unattach(WebGraphicsContext3D* context, GLenum target, GLenum attachment)
+void WebGLRenderbufferAttachment::unattach(gpu::gles2::GLES2Interface* gl, GLenum target, GLenum attachment)
 {
-    context->framebufferRenderbuffer(target, attachment, GL_RENDERBUFFER, 0);
+    gl->FramebufferRenderbuffer(target, attachment, GL_RENDERBUFFER, 0);
 }
 
 class WebGLTextureAttachment final : public WebGLFramebuffer::WebGLAttachment {
 public:
     static WebGLFramebuffer::WebGLAttachment* create(WebGLTexture*, GLenum target, GLint level, GLint layer);
 
     DECLARE_VIRTUAL_TRACE();
 
 private:
     WebGLTextureAttachment(WebGLTexture*, GLenum target, GLint level, GLint layer);
     WebGLTextureAttachment() { }
 
     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;
+    void attach(gpu::gles2::GLES2Interface*, GLenum target, GLenum attachment) override;
+    void unattach(gpu::gles2::GLES2Interface*, GLenum target, GLenum attachment) override;
 
     Member<WebGLTexture> m_texture;
     GLenum m_target;
     GLint m_level;
     GLint m_layer;
 };
 
 WebGLFramebuffer::WebGLAttachment* WebGLTextureAttachment::create(WebGLTexture* texture, GLenum target, GLint level, GLint layer)
 {
     return new WebGLTextureAttachment(texture, target, level, layer);
@@ skipping 26 matching lines @@
 bool WebGLTextureAttachment::valid() const
 {
     return m_texture->object();
 }
 
 void WebGLTextureAttachment::onDetached(WebGraphicsContext3D* context)
 {
     m_texture->onDetached(context);
 }
 
-void WebGLTextureAttachment::attach(WebGraphicsContext3D* context, GLenum target, GLenum attachment)
+void WebGLTextureAttachment::attach(gpu::gles2::GLES2Interface* gl, GLenum target, GLenum attachment)
 {
     Platform3DObject object = objectOrZero(m_texture.get());
     if (m_target == GL_TEXTURE_3D || m_target == GL_TEXTURE_2D_ARRAY) {
-        context->framebufferTextureLayer(target, attachment, object, m_level, m_layer);
+        gl->FramebufferTextureLayer(target, attachment, object, m_level, m_layer);
     } else {
-        context->framebufferTexture2D(target, attachment, m_target, object, m_level);
+        gl->FramebufferTexture2D(target, attachment, m_target, object, m_level);
     }
 }
 
-void WebGLTextureAttachment::unattach(WebGraphicsContext3D* context, GLenum target, GLenum attachment)
+void WebGLTextureAttachment::unattach(gpu::gles2::GLES2Interface* gl, GLenum target, GLenum attachment)
 {
     // GL_DEPTH_STENCIL_ATTACHMENT attachment is valid in ES3.
     if (m_target == GL_TEXTURE_3D || m_target == GL_TEXTURE_2D_ARRAY) {
-        context->framebufferTextureLayer(target, attachment, 0, m_level, m_layer);
+        gl->FramebufferTextureLayer(target, attachment, 0, m_level, m_layer);
     } else {
-        context->framebufferTexture2D(target, attachment, m_target, 0, m_level);
+        gl->FramebufferTexture2D(target, attachment, m_target, 0, m_level);
     }
 }
 
 } // anonymous namespace
 
 WebGLFramebuffer::WebGLAttachment::WebGLAttachment()
 {
 }
 
 WebGLFramebuffer::WebGLAttachment::~WebGLAttachment()
@@ skipping 49 matching lines @@
         drawBuffersIfNecessary(false);
         renderbuffer->onAttached();
     }
 }
 
 void WebGLFramebuffer::attach(GLenum target, GLenum attachment, GLenum attachmentPoint)
 {
     ASSERT(isBound(target));
     WebGLAttachment* attachmentObject = getAttachment(attachment);
     if (attachmentObject)
-        attachmentObject->attach(context()->webContext(), target, attachmentPoint);
+        attachmentObject->attach(context()->contextGL(), target, attachmentPoint);
 }
 
 WebGLSharedObject* WebGLFramebuffer::getAttachmentObject(GLenum attachment) const
 {
     if (!m_object)
         return nullptr;
     WebGLAttachment* attachmentObject = getAttachment(attachment);
     return attachmentObject ? attachmentObject->object() : nullptr;
 }
 
@@ skipping 35 matching lines @@
     if (!attachment)
         return;
 
     bool checkMore = true;
     while (checkMore) {
         checkMore = false;
         for (const auto& it : m_attachments) {
             WebGLAttachment* attachmentObject = it.value.get();
             if (attachmentObject->isSharedObject(attachment)) {
                 GLenum attachmentType = it.key;
-                attachmentObject->unattach(context()->webContext(), target, attachmentType);
+                attachmentObject->unattach(context()->contextGL(), target, attachmentType);
                 removeAttachmentFromBoundFramebuffer(target, attachmentType);
                 checkMore = true;
                 break;
             }
         }
     }
 }
 
 GLenum WebGLFramebuffer::checkDepthStencilStatus(const char** reason) const
 {
@@ skipping 102 matching lines @@
     return GL_NONE;
 }
 
 DEFINE_TRACE(WebGLFramebuffer)
 {
     visitor->trace(m_attachments);
     WebGLContextObject::trace(visitor);
 }
 
 } // namespace blink