Move simple methods [T-Z] from WebGraphicsContext3D to GLES2Interface.

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
@@ skipping 30 matching lines @@
 
     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 onDetached(WebGraphicsContext3D*, gpu::gles2::GLES2Interface*) 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);
 }
@@ skipping 17 matching lines @@
 bool WebGLRenderbufferAttachment::isSharedObject(WebGLSharedObject* object) const
 {
     return object == m_renderbuffer;
 }
 
 bool WebGLRenderbufferAttachment::valid() const
 {
     return m_renderbuffer->object();
 }
 
-void WebGLRenderbufferAttachment::onDetached(WebGraphicsContext3D* context)
+void WebGLRenderbufferAttachment::onDetached(WebGraphicsContext3D* context, gpu::gles2::GLES2Interface* gl)
 {
-    m_renderbuffer->onDetached(context);
+    m_renderbuffer->onDetached(context, gl);
 }
 
 void WebGLRenderbufferAttachment::attach(gpu::gles2::GLES2Interface* gl, GLenum target, GLenum attachment)
 {
     Platform3DObject object = objectOrZero(m_renderbuffer.get());
     gl->FramebufferRenderbuffer(target, attachment, GL_RENDERBUFFER, object);
 }
 
 void WebGLRenderbufferAttachment::unattach(gpu::gles2::GLES2Interface* gl, GLenum target, GLenum attachment)
 {
     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 onDetached(WebGraphicsContext3D*, gpu::gles2::GLES2Interface*) 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)
@@ skipping 23 matching lines @@
 bool WebGLTextureAttachment::isSharedObject(WebGLSharedObject* object) const
 {
     return object == m_texture;
 }
 
 bool WebGLTextureAttachment::valid() const
 {
     return m_texture->object();
 }
 
-void WebGLTextureAttachment::onDetached(WebGraphicsContext3D* context)
+void WebGLTextureAttachment::onDetached(WebGraphicsContext3D* context, gpu::gles2::GLES2Interface* gl)
 {
-    m_texture->onDetached(context);
+    m_texture->onDetached(context, gl);
 }
 
 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) {
         gl->FramebufferTextureLayer(target, attachment, object, m_level, m_layer);
     } else {
         gl->FramebufferTexture2D(target, attachment, m_target, object, m_level);
     }
@@ skipping 93 matching lines @@
 }
 
 void WebGLFramebuffer::removeAttachmentFromBoundFramebuffer(GLenum target, GLenum attachment)
 {
     ASSERT(isBound(target));
     if (!m_object)
         return;
 
     WebGLAttachment* attachmentObject = getAttachment(attachment);
     if (attachmentObject) {
-        attachmentObject->onDetached(context()->webContext());
+        attachmentObject->onDetached(context()->webContext(), context()->contextGL());
         m_attachments.remove(attachment);
         drawBuffersIfNecessary(false);
         switch (attachment) {
         case GL_DEPTH_STENCIL_ATTACHMENT:
             attach(target, GL_DEPTH_ATTACHMENT, GL_DEPTH_ATTACHMENT);
             attach(target, GL_STENCIL_ATTACHMENT, GL_STENCIL_ATTACHMENT);
             break;
         case GL_DEPTH_ATTACHMENT:
         case GL_STENCIL_ATTACHMENT:
             attach(target, GL_DEPTH_STENCIL_ATTACHMENT, GL_DEPTH_STENCIL_ATTACHMENT);
@@ skipping 59 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)
+void WebGLFramebuffer::deleteObjectImpl(WebGraphicsContext3D* context3d, gpu::gles2::GLES2Interface* gl)
 {
     // Both the AttachmentMap and its WebGLAttachment objects are GCed
     // objects and cannot be accessed after the destructor has been
     // entered, as they may have been finalized already during the
     // same GC sweep. These attachments' OpenGL objects will be fully
     // destroyed once their JavaScript wrappers are collected.
     if (!m_destructionInProgress) {
         for (const auto& attachment : m_attachments)
-            attachment.value->onDetached(context3d);
+            attachment.value->onDetached(context3d, gl);
     }
 
     context3d->deleteFramebuffer(m_object);
     m_object = 0;
 }
 
 bool WebGLFramebuffer::isBound(GLenum target) const
 {
     return (context()->getFramebufferBinding(target) == this);
 }
@@ skipping 20 matching lines @@
                     reset = true;
                 }
             } else {
                 if (m_filteredDrawBuffers[i] != GL_NONE) {
                     m_filteredDrawBuffers[i] = GL_NONE;
                     reset = true;
                 }
             }
         }
         if (reset) {
-            context()->webContext()->drawBuffersEXT(
+            context()->contextGL()->DrawBuffersEXT(
                 m_filteredDrawBuffers.size(), m_filteredDrawBuffers.data());
         }
     }
 }
 
 GLenum WebGLFramebuffer::getDrawBuffer(GLenum drawBuffer)
 {
     int index = static_cast<int>(drawBuffer - GL_DRAW_BUFFER0_EXT);
     ASSERT(index >= 0);
     if (index < static_cast<int>(m_drawBuffers.size()))
         return m_drawBuffers[index];
     if (drawBuffer == GL_DRAW_BUFFER0_EXT)
         return GL_COLOR_ATTACHMENT0;
     return GL_NONE;
 }
 
 DEFINE_TRACE(WebGLFramebuffer)
 {
     visitor->trace(m_attachments);
     WebGLContextObject::trace(visitor);
 }
 
 } // namespace blink