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;

[Ken Russell (switch to Gerrit), 2016/09/29 03:07:43]

It's awesome that the command buffer's knowledge of the WebGL 1.0 rules could be
centralized to this one place.

I re-checked all of the code paths in the command decoder like:
 - generating GL_INVALID_FRAMEBUFFER_OPERATION during calls writing to the draw
framebuffer
 - lazily reallocating bound framebuffers' storage and making sure that isn't
missed

and it looks like this handles all cases. Mo, can you think of anything that
could be missed and doesn't have tests?

   }
 
   // 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