Move the WebGL DrawBuffers support check to the command buffer service.

gpu/command_buffer/service/feature_info.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "gpu/command_buffer/service/feature_info.h"
 
 #include <stddef.h>
 
 #include <set>
 #include <vector>
@@ skipping 88 matching lines @@
   ~ScopedPixelUnpackBufferOverride() {
     if (orig_binding_ != -1) {
       glBindBuffer(GL_PIXEL_UNPACK_BUFFER, static_cast<GLuint>(orig_binding_));
     }
   }
 
  private:
     GLint orig_binding_;
 };
 
+bool IsWebGLDrawBuffersSupported(GLenum depth_texture_internal_format,
+                                 GLenum depth_stencil_texture_internal_format) {
+  // This is called after we make sure GL_EXT_draw_buffers is supported.
+  GLint max_draw_buffers = 0;
+  GLint max_color_attachments = 0;
+  glGetIntegerv(GL_MAX_DRAW_BUFFERS, &max_draw_buffers);
+  glGetIntegerv(GL_MAX_COLOR_ATTACHMENTS, &max_color_attachments);
+  if (max_draw_buffers < 4 || max_color_attachments < 4) {
+    return false;
+  }
+
+  GLint fb_binding = 0;
+  GLint tex_binding = 0;
+  glGetIntegerv(GL_FRAMEBUFFER_BINDING, &fb_binding);
+  glGetIntegerv(GL_TEXTURE_BINDING_2D, &tex_binding);
+
+  GLuint fbo;
+  glGenFramebuffersEXT(1, &fbo);
+  glBindFramebufferEXT(GL_FRAMEBUFFER, fbo);
+
+  GLuint depth_stencil_texture = 0;
+  if (depth_stencil_texture_internal_format != GL_NONE) {
+    glGenTextures(1, &depth_stencil_texture);
+    glBindTexture(GL_TEXTURE_2D, depth_stencil_texture);
+    glTexImage2D(GL_TEXTURE_2D, 0, depth_stencil_texture_internal_format, 1, 1,
+                 0, GL_DEPTH_STENCIL, GL_UNSIGNED_INT_24_8, nullptr);
+  }
+
+  GLuint depth_texture = 0;
+  if (depth_texture_internal_format != GL_NONE) {
+    glGenTextures(1, &depth_texture);
+    glBindTexture(GL_TEXTURE_2D, depth_texture);
+    glTexImage2D(GL_TEXTURE_2D, 0, depth_texture_internal_format, 1, 1, 0,
+                 GL_DEPTH_COMPONENT, GL_UNSIGNED_INT, nullptr);
+  }
+
+  GLint max_allowed_buffers = std::min(max_draw_buffers, max_color_attachments);
+  std::vector<GLuint> colors(max_allowed_buffers, 0);
+  glGenTextures(max_allowed_buffers, colors.data());
+
+  bool result = true;
+  for (GLint i = 0; i < max_allowed_buffers; ++i) {
+    GLint color = colors[i];
+    glBindTexture(GL_TEXTURE_2D, color);
+    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 1, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE,
+                 nullptr);
+    glFramebufferTexture2DEXT(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0 + i,
+                              GL_TEXTURE_2D, color, 0);
+    if (glCheckFramebufferStatusEXT(GL_FRAMEBUFFER) !=
+        GL_FRAMEBUFFER_COMPLETE) {
+      result = false;
+      break;
+    }
+    if (depth_texture != 0) {
+      glFramebufferTexture2DEXT(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT,
+                                GL_TEXTURE_2D, depth_texture, 0);
+      if (glCheckFramebufferStatusEXT(GL_FRAMEBUFFER) !=
+          GL_FRAMEBUFFER_COMPLETE) {
+        result = false;
+        break;
+      }
+      glFramebufferTexture2DEXT(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT,
+                                GL_TEXTURE_2D, 0, 0);
+    }
+    if (depth_stencil_texture != 0) {
+      // For ES 2.0 contexts DEPTH_STENCIL is not available natively, so we
+      // emulate it at the command buffer level for WebGL contexts.
+      glFramebufferTexture2DEXT(GL_FRAMEBUFFER, GL_DEPTH_STENCIL_ATTACHMENT,
+                                GL_TEXTURE_2D, depth_stencil_texture, 0);
+      if (glCheckFramebufferStatusEXT(GL_FRAMEBUFFER) !=
+          GL_FRAMEBUFFER_COMPLETE) {
+        result = false;
+        break;
+      }
+      glFramebufferTexture2DEXT(GL_FRAMEBUFFER, GL_DEPTH_STENCIL_ATTACHMENT,
+                                GL_TEXTURE_2D, 0, 0);
+    }
+  }
+
+  glBindFramebufferEXT(GL_FRAMEBUFFER, static_cast<GLuint>(fb_binding));
+  glDeleteFramebuffersEXT(1, &fbo);
+
+  glBindTexture(GL_TEXTURE_2D, static_cast<GLuint>(tex_binding));
+  glDeleteTextures(1, &depth_texture);
+  glDeleteTextures(1, &depth_stencil_texture);
+  glDeleteTextures(colors.size(), colors.data());
+
+  DCHECK(glGetError() == GL_NO_ERROR);
+
+  return result;
+}
+
 }  // anonymous namespace.
 
 FeatureInfo::FeatureFlags::FeatureFlags() {}
 
 FeatureInfo::FeatureInfo() {
   InitializeBasicState(base::CommandLine::InitializedForCurrentProcess()
                            ? base::CommandLine::ForCurrentProcess()
                            : nullptr);
 }
 
@@ skipping 317 matching lines @@
   // NOTE: GL_OES_depth_texture requires support for depth cubemaps.
   // GL_ARB_depth_texture requires other features that
   // GL_OES_packed_depth_stencil does not provide.
   //
   // Therefore we made up GL_GOOGLE_depth_texture / GL_CHROMIUM_depth_texture.
   //
   // GL_GOOGLE_depth_texture is legacy. As we exposed it into NaCl we can't
   // get rid of it.
   //
   bool enable_depth_texture = false;
+  GLenum depth_texture_format = GL_NONE;
   if (!workarounds_.disable_depth_texture &&
       (extensions.Contains("GL_ARB_depth_texture") ||
        extensions.Contains("GL_OES_depth_texture") ||
        extensions.Contains("GL_ANGLE_depth_texture") ||
        gl_version_info_->is_desktop_core_profile)) {
     // Note that we don't expose depth_texture extenion on top of ES3 if
     // the depth_texture extension isn't exposed by the ES3 driver.
     // This is because depth textures are filterable under linear mode in
     // ES2 + extension, but not in core ES3.
     enable_depth_texture = true;
+    depth_texture_format = GL_DEPTH_COMPONENT;
     feature_flags_.angle_depth_texture =
         extensions.Contains("GL_ANGLE_depth_texture");
   }
 
   if (enable_depth_texture) {
     AddExtensionString("GL_CHROMIUM_depth_texture");
     AddExtensionString("GL_GOOGLE_depth_texture");
     validators_.texture_internal_format.AddValue(GL_DEPTH_COMPONENT);
     validators_.texture_format.AddValue(GL_DEPTH_COMPONENT);
     validators_.pixel_type.AddValue(GL_UNSIGNED_SHORT);
     validators_.pixel_type.AddValue(GL_UNSIGNED_INT);
     validators_.texture_depth_renderable_internal_format.AddValue(
         GL_DEPTH_COMPONENT);
   }
 
+  GLenum depth_stencil_texture_format = GL_NONE;
   if (extensions.Contains("GL_EXT_packed_depth_stencil") ||
       extensions.Contains("GL_OES_packed_depth_stencil") ||
       gl_version_info_->is_es3 ||
       gl_version_info_->is_desktop_core_profile) {
     AddExtensionString("GL_OES_packed_depth_stencil");
     feature_flags_.packed_depth24_stencil8 = true;
     if (enable_depth_texture) {
+      if (gl_version_info_->is_es3) {
+        depth_stencil_texture_format = GL_DEPTH24_STENCIL8;
+      } else {
+        depth_stencil_texture_format = GL_DEPTH_STENCIL;
+      }
       validators_.texture_internal_format.AddValue(GL_DEPTH_STENCIL);
       validators_.texture_format.AddValue(GL_DEPTH_STENCIL);
       validators_.pixel_type.AddValue(GL_UNSIGNED_INT_24_8);
       validators_.texture_depth_renderable_internal_format.AddValue(
           GL_DEPTH_STENCIL);
       validators_.texture_stencil_renderable_internal_format.AddValue(
           GL_DEPTH_STENCIL);
     }
     validators_.render_buffer_format.AddValue(GL_DEPTH24_STENCIL8);
     if (context_type_ == CONTEXT_TYPE_WEBGL1) {
@@ skipping 666 matching lines @@
     feature_flags_.angle_instanced_arrays = true;
     validators_.vertex_attribute.AddValue(GL_VERTEX_ATTRIB_ARRAY_DIVISOR_ANGLE);
   }
 
   bool have_es2_draw_buffers_vendor_agnostic =
       gl_version_info_->is_desktop_core_profile ||
       extensions.Contains("GL_ARB_draw_buffers") ||
       extensions.Contains("GL_EXT_draw_buffers");
   bool can_emulate_es2_draw_buffers_on_es3_nv =
       gl_version_info_->is_es3 && extensions.Contains("GL_NV_draw_buffers");
-  bool have_es2_draw_buffers = !workarounds_.disable_ext_draw_buffers &&
-                               IsWebGL1OrES2Context() &&
-                               (have_es2_draw_buffers_vendor_agnostic ||
-                                can_emulate_es2_draw_buffers_on_es3_nv);
+  bool have_es2_draw_buffers =
+      !workarounds_.disable_ext_draw_buffers &&
+      (have_es2_draw_buffers_vendor_agnostic ||
+       can_emulate_es2_draw_buffers_on_es3_nv) &&
+      (context_type_ == CONTEXT_TYPE_OPENGLES2 ||
+       (context_type_ == CONTEXT_TYPE_WEBGL1 &&
+        IsWebGLDrawBuffersSupported(depth_texture_format,
+                                    depth_stencil_texture_format)));
   if (have_es2_draw_buffers) {
     AddExtensionString("GL_EXT_draw_buffers");
     feature_flags_.ext_draw_buffers = true;
 
     // This flag is set to enable emulation of EXT_draw_buffers when we're
     // running on GLES 3.0+, NV_draw_buffers extension is supported and
     // glDrawBuffers from GLES 3.0 core has been bound. It toggles using the
     // NV_draw_buffers extension directive instead of EXT_draw_buffers extension
     // directive in ESSL 100 shaders translated by ANGLE, enabling them to write
     // into multiple gl_FragData values, which is not by default possible in
@@ skipping 350 matching lines @@
   if (pos == std::string::npos) {
     extensions_ += (extensions_.empty() ? "" : " ") + str;
   }
 }
 
 FeatureInfo::~FeatureInfo() {
 }
 
 }  // namespace gles2
 }  // namespace gpu