Move special DEPTH_STENCIL attachment logic from command buffers to WebGL1

gpu/command_buffer/service/framebuffer_manager.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/framebuffer_manager.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/strings/stringprintf.h"
 #include "gpu/command_buffer/common/gles2_cmd_utils.h"
 #include "gpu/command_buffer/service/framebuffer_completeness_cache.h"
 #include "gpu/command_buffer/service/renderbuffer_manager.h"
 #include "gpu/command_buffer/service/texture_manager.h"
 #include "ui/gl/gl_bindings.h"
 
 namespace gpu {
 namespace gles2 {
 
-namespace {
-
-bool DetectWebGL1DepthStencilAttachmentConflicts(
-    uint32_t needed_channels, uint32_t channels) {
-  switch (needed_channels) {
-    case GLES2Util::kDepth:
-    case GLES2Util::kStencil:
-    case GLES2Util::kDepth | GLES2Util::kStencil:
-      return (needed_channels != channels);
-    default:
-      return false;
-  }
-}
-
-}  // namespace anonymous
-
 DecoderFramebufferState::DecoderFramebufferState()
     : clear_state_dirty(false),
       bound_read_framebuffer(NULL),
       bound_draw_framebuffer(NULL) {
 }
 
 DecoderFramebufferState::~DecoderFramebufferState() {
 }
 
 class RenderbufferAttachment
@@ skipping 54 matching lines @@
 
   bool CanRenderTo(const FeatureInfo*) const override { return true; }
 
   void DetachFromFramebuffer(Framebuffer* framebuffer) const override {
     // Nothing to do for renderbuffers.
   }
 
   bool IsLayerValid() const override { return true; }
 
   bool ValidForAttachmentType(GLenum attachment_type,
-                              ContextType context_type,
                               uint32_t max_color_attachments) override {
     uint32_t need = GLES2Util::GetChannelsNeededForAttachmentType(
         attachment_type, max_color_attachments);
     DCHECK_NE(0u, need);
     uint32_t have = GLES2Util::GetChannelsForFormat(internal_format());
-    if (context_type == CONTEXT_TYPE_WEBGL1 &&
-        DetectWebGL1DepthStencilAttachmentConflicts(need, have))
-      return false;
     return (need & have) != 0;
   }
 
   Renderbuffer* renderbuffer() const {
     return renderbuffer_.get();
   }
 
   size_t GetSignatureSize(TextureManager* texture_manager) const override {
     return renderbuffer_->GetSignatureSize();
   }
@@ skipping 133 matching lines @@
 
   bool IsLayerValid() const override {
     Texture* texture = texture_ref_->texture();
     DCHECK(texture);
     GLsizei width, height, depth;
     return (texture->GetLevelSize(target_, level_, &width, &height, &depth) &&
             layer_ < depth);
   }
 
   bool ValidForAttachmentType(GLenum attachment_type,
-                              ContextType context_type,
                               uint32_t max_color_attachments) override {
     GLenum type = 0;
     GLenum internal_format = 0;
     if (!texture_ref_->texture()->GetLevelType(
         target_, level_, &type, &internal_format)) {
       return false;
     }
     uint32_t need = GLES2Util::GetChannelsNeededForAttachmentType(
         attachment_type, max_color_attachments);
     DCHECK_NE(0u, need);
     uint32_t have = GLES2Util::GetChannelsForFormat(internal_format);
 
     // Workaround for NVIDIA drivers that incorrectly expose these formats as
     // renderable:
     if (internal_format == GL_LUMINANCE || internal_format == GL_ALPHA ||
         internal_format == GL_LUMINANCE_ALPHA) {
       return false;
     }
-    if (context_type == CONTEXT_TYPE_WEBGL1 &&
-        DetectWebGL1DepthStencilAttachmentConflicts(need, have))
-      return need == have;
     return (need & have) != 0;
   }
 
   size_t GetSignatureSize(TextureManager* texture_manager) const override {
     return texture_manager->GetSignatureSize();
   }
 
   void AddToSignature(TextureManager* texture_manager,
                       std::string* signature) const override {
     DCHECK(signature);
@@ skipping 20 matching lines @@
   GLint level_;
   GLsizei samples_;
   GLint layer_;
 
   DISALLOW_COPY_AND_ASSIGN(TextureAttachment);
 };
 
 FramebufferManager::FramebufferManager(
     uint32_t max_draw_buffers,
     uint32_t max_color_attachments,
-    ContextType context_type,
     const scoped_refptr<FramebufferCompletenessCache>&
         framebuffer_combo_complete_cache)
     : framebuffer_state_change_count_(1),
       framebuffer_count_(0),
       have_context_(true),
       max_draw_buffers_(max_draw_buffers),
       max_color_attachments_(max_color_attachments),
-      context_type_(context_type),
       framebuffer_combo_complete_cache_(framebuffer_combo_complete_cache) {
   DCHECK_GT(max_draw_buffers_, 0u);
   DCHECK_GT(max_color_attachments_, 0u);
 }
 
 FramebufferManager::~FramebufferManager() {
   DCHECK(framebuffers_.empty());
   // If this triggers, that means something is keeping a reference to a
   // Framebuffer belonging to this.
   CHECK_EQ(framebuffer_count_, 0u);
@@ skipping 64 matching lines @@
       glDeleteFramebuffersEXT(1, &id);
     }
     manager_->StopTracking(this);
     manager_ = NULL;
   }
 }
 
 bool Framebuffer::HasUnclearedAttachment(
     GLenum attachment_type) const {
   const Attachment* attachment = GetAttachment(attachment_type);
-  switch (attachment_type) {
-    case GL_DEPTH_ATTACHMENT:
-    case GL_STENCIL_ATTACHMENT:
-      attachment = attachment ? attachment :
-          GetAttachment(GL_DEPTH_STENCIL_ATTACHMENT);
-      break;
-   default:
-      break;
-  }
   return attachment && !attachment->cleared();
 }
 
 bool Framebuffer::HasDepthStencilFormatAttachment() const {
   const Attachment* depth_attachment = GetAttachment(GL_DEPTH_ATTACHMENT);
   const Attachment* stencil_attachment = GetAttachment(GL_STENCIL_ATTACHMENT);
-  const Attachment* depth_stencil_attachment = GetAttachment(
-      GL_DEPTH_STENCIL_ATTACHMENT);
   if (depth_attachment && stencil_attachment) {
     GLenum depth_format = depth_attachment->internal_format();
     depth_format = TextureManager::ExtractFormatFromStorageFormat(depth_format);
     GLenum stencil_format = stencil_attachment->internal_format();
     stencil_format = TextureManager::ExtractFormatFromStorageFormat(
         stencil_format);
     return depth_format == GL_DEPTH_STENCIL &&
-        stencil_format == GL_DEPTH_STENCIL;
-  }
-  if (depth_stencil_attachment) {
-    GLenum depth_stencil_format = depth_stencil_attachment->internal_format();
-    depth_stencil_format = TextureManager::ExtractFormatFromStorageFormat(
-        depth_stencil_format);
-    return depth_stencil_format == GL_DEPTH_STENCIL;
+           stencil_format == GL_DEPTH_STENCIL;
   }
   return false;
 }
 
 bool Framebuffer::HasUnclearedColorAttachments() const {
   for (AttachmentMap::const_iterator it = attachments_.begin();
        it != attachments_.end(); ++it) {
     if (it->first >= GL_COLOR_ATTACHMENT0 &&
         it->first < GL_COLOR_ATTACHMENT0 + manager_->max_draw_buffers_) {
       const Attachment* attachment = it->second.get();
@@ skipping 170 matching lines @@
       attachment->SetCleared(renderbuffer_manager, texture_manager, cleared);
     }
   }
 }
 
 bool Framebuffer::HasColorAttachment(int index) const {
   return attachments_.find(GL_COLOR_ATTACHMENT0 + index) != attachments_.end();
 }
 
 bool Framebuffer::HasDepthAttachment() const {
-  return attachments_.find(GL_DEPTH_STENCIL_ATTACHMENT) != attachments_.end() ||
-         attachments_.find(GL_DEPTH_ATTACHMENT) != attachments_.end();
+  return attachments_.find(GL_DEPTH_ATTACHMENT) != attachments_.end();
 }
 
 bool Framebuffer::HasStencilAttachment() const {
-  return attachments_.find(GL_DEPTH_STENCIL_ATTACHMENT) != attachments_.end() ||
-         attachments_.find(GL_STENCIL_ATTACHMENT) != attachments_.end();
+  return attachments_.find(GL_STENCIL_ATTACHMENT) != attachments_.end();
 }
 
 GLenum Framebuffer::GetReadBufferInternalFormat() const {
   if (read_buffer_ == GL_NONE)
     return 0;
   AttachmentMap::const_iterator it = attachments_.find(read_buffer_);
   if (it == attachments_.end()) {
     return 0;
   }
   const Attachment* attachment = it->second.get();
@@ skipping 18 matching lines @@
 GLsizei Framebuffer::GetSamples() const {
   // Assume the framebuffer is complete, so return any attachment's samples.
   auto iter = attachments_.begin();
   if (iter == attachments_.end())
     return -1;
   Attachment* attachment = iter->second.get();
   DCHECK(attachment);
   return attachment->samples();
 }
 
-const Framebuffer::Attachment* Framebuffer::GetDepthAttachment() const {
-  auto iter = attachments_.find(GL_DEPTH_STENCIL_ATTACHMENT);
+GLenum Framebuffer::GetDepthFormat() const {
+  auto iter = attachments_.find(GL_DEPTH_ATTACHMENT);
   if (iter == attachments_.end())
-    iter = attachments_.find(GL_DEPTH_ATTACHMENT);
-  if (iter == attachments_.end())
-    return nullptr;
+    return 0;
   Attachment* attachment = iter->second.get();
   DCHECK(attachment);
-  return attachment;
-}
-
-const Framebuffer::Attachment* Framebuffer::GetStencilAttachment() const {
-  auto iter = attachments_.find(GL_DEPTH_STENCIL_ATTACHMENT);
-  if (iter == attachments_.end())
-    iter = attachments_.find(GL_STENCIL_ATTACHMENT);
-  if (iter == attachments_.end())
-    return nullptr;
-  Attachment* attachment = iter->second.get();
-  DCHECK(attachment);
-  return attachment;
-}
-
-GLenum Framebuffer::GetDepthFormat() const {
-  const Attachment* attachment = GetDepthAttachment();
-  return attachment ? attachment->internal_format() : 0;
+  return attachment->internal_format();
 }
 
 GLenum Framebuffer::GetStencilFormat() const {
-  const Attachment* attachment = GetStencilAttachment();
-  return attachment ? attachment->internal_format() : 0;
+  auto iter = attachments_.find(GL_STENCIL_ATTACHMENT);
+  if (iter == attachments_.end())
+    return 0;
+  Attachment* attachment = iter->second.get();
+  DCHECK(attachment);
+  return attachment->internal_format();
 }
 
 GLenum Framebuffer::IsPossiblyComplete(const FeatureInfo* feature_info) const {
   if (attachments_.empty()) {
     return GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT;
   }
 
   GLsizei width = -1;
   GLsizei height = -1;
   GLsizei samples = -1;
   const bool kSamplesMustMatch = feature_info->IsWebGLContext() ||
       !feature_info->feature_flags().chromium_framebuffer_mixed_samples;
 
   for (AttachmentMap::const_iterator it = attachments_.begin();
        it != attachments_.end(); ++it) {
     GLenum attachment_type = it->first;
     Attachment* attachment = it->second.get();
     if (!attachment->ValidForAttachmentType(attachment_type,
-                                            feature_info->context_type(),
                                             manager_->max_color_attachments_)) {
       return GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT;
     }
     if (!attachment->IsLayerValid()) {
       return GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT;
     }
     if (width < 0) {
       width = attachment->width();
       height = attachment->height();
       if (width == 0 || height == 0) {
@@ skipping 35 matching lines @@
   }
 
   // Binding different images to depth and stencil attachment points should
   // return FRAMEBUFFER_UNSUPPORTED.
   const Attachment* depth_attachment = GetAttachment(GL_DEPTH_ATTACHMENT);
   const Attachment* stencil_attachment = GetAttachment(GL_STENCIL_ATTACHMENT);
   if (depth_attachment && stencil_attachment) {
     if (!depth_attachment->IsSameAttachment(stencil_attachment)) {
       return GL_FRAMEBUFFER_UNSUPPORTED;
     }
+    DCHECK_EQ(depth_attachment->internal_format(),
+              stencil_attachment->internal_format());
+  }
+  if (feature_info->context_type() == CONTEXT_TYPE_WEBGL1) {
+    // WebGL1 has specific additional restrictions on depth and stencil
+    // attachments (e.g. it is forbidden to bind a DEPTH_STENCIL attachement to
+    // a (pure) GL_DEPTH_ATTACHMENT. Note that in WebGL1,
+    // GL_DEPTH_STENCIL_ATTACHMENT is a separate bind point, but that logic is
+    // handled in Blink and translated to
+    // GL_DEPTH_ATTACHMENT+GL_STENCIL_ATTACHMENT.
+    uint32_t need_channels = 0;
+    uint32_t have_channels = 0;
+    if (depth_attachment) {
+      need_channels |= GLES2Util::kDepth;
+      have_channels |=
+          GLES2Util::GetChannelsForFormat(depth_attachment->internal_format());
+    }
+    if (stencil_attachment) {
+      need_channels |= GLES2Util::kStencil;
+      have_channels |= GLES2Util::GetChannelsForFormat(
+          stencil_attachment->internal_format());
+    }
+    if (need_channels != have_channels)
+      return GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT;
   }
 
   // This does not mean the framebuffer is actually complete. It just means our
   // checks passed.
   return GL_FRAMEBUFFER_COMPLETE;
 }
 
 GLenum Framebuffer::GetStatus(
     TextureManager* texture_manager, GLenum target) const {
   if (!manager_->GetFramebufferComboCompleteCache()) {
@@ skipping 181 matching lines @@
 void Framebuffer::DoUnbindGLAttachmentsForWorkaround(GLenum target) {
   // Replace all attachments with the default Renderbuffer.
   for (AttachmentMap::const_iterator it = attachments_.begin();
        it != attachments_.end(); ++it) {
     glFramebufferRenderbufferEXT(target, it->first, GL_RENDERBUFFER, 0);
   }
 }
 
 void Framebuffer::AttachRenderbuffer(
     GLenum attachment, Renderbuffer* renderbuffer) {
+  DCHECK(attachment != GL_DEPTH_STENCIL_ATTACHMENT);
   const Attachment* a = GetAttachment(attachment);
   if (a)
     a->DetachFromFramebuffer(this);
   if (renderbuffer) {
     attachments_[attachment] = scoped_refptr<Attachment>(
         new RenderbufferAttachment(renderbuffer));
   } else {
     attachments_.erase(attachment);
   }
   framebuffer_complete_state_count_id_ = 0;
 }
 
 void Framebuffer::AttachTexture(
     GLenum attachment, TextureRef* texture_ref, GLenum target,
     GLint level, GLsizei samples) {
+  DCHECK(attachment != GL_DEPTH_STENCIL_ATTACHMENT);
   const Attachment* a = GetAttachment(attachment);
   if (a)
     a->DetachFromFramebuffer(this);
   if (texture_ref) {
     attachments_[attachment] = scoped_refptr<Attachment>(
         new TextureAttachment(texture_ref, target, level, samples, 0));
     texture_ref->texture()->AttachToFramebuffer();
   } else {
     attachments_.erase(attachment);
   }
   framebuffer_complete_state_count_id_ = 0;
 }
 
 void Framebuffer::AttachTextureLayer(
     GLenum attachment, TextureRef* texture_ref, GLenum target,
     GLint level, GLint layer) {
+  DCHECK(attachment != GL_DEPTH_STENCIL_ATTACHMENT);
   const Attachment* a = GetAttachment(attachment);
   if (a)
     a->DetachFromFramebuffer(this);
   if (texture_ref) {
     attachments_[attachment] = scoped_refptr<Attachment>(
         new TextureAttachment(texture_ref, target, level, 0, layer));
     texture_ref->texture()->AttachToFramebuffer();
   } else {
     attachments_.erase(attachment);
   }
@@ skipping 48 matching lines @@
 
 bool FramebufferManager::IsComplete(
     Framebuffer* framebuffer) {
   DCHECK(framebuffer);
   return framebuffer->framebuffer_complete_state_count_id() ==
       framebuffer_state_change_count_;
 }
 
 }  // namespace gles2
 }  // namespace gpu