Remove WebGraphicsContext3D::getGLES2Interface().

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*, gpu::gles2::GLES2Interface*) override;
+    void onDetached(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, gpu::gles2::GLES2Interface* gl)
+void WebGLRenderbufferAttachment::onDetached(gpu::gles2::GLES2Interface* gl)
 {
-    m_renderbuffer->onDetached(context, gl);
+    m_renderbuffer->onDetached(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*, gpu::gles2::GLES2Interface*) override;
+    void onDetached(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, gpu::gles2::GLES2Interface* gl)
+void WebGLTextureAttachment::onDetached(gpu::gles2::GLES2Interface* gl)
 {
-    m_texture->onDetached(context, gl);
+    m_texture->onDetached(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 94 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(), context()->contextGL());
+        attachmentObject->onDetached(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, gpu::gles2::GLES2Interface* gl)
+void WebGLFramebuffer::deleteObjectImpl(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, gl);
+            attachment.value->onDetached(gl);
     }
 
     gl->DeleteFramebuffers(1, &m_object);
     m_object = 0;
 }
 
 bool WebGLFramebuffer::isBound(GLenum target) const
 {
     return (context()->getFramebufferBinding(target) == this);
 }
@@ skipping 44 matching lines @@
     return GL_NONE;
 }
 
 DEFINE_TRACE(WebGLFramebuffer)
 {
     visitor->trace(m_attachments);
     WebGLContextObject::trace(visitor);
 }
 
 } // namespace blink