Split DEPTH_STENCIL into DEPTH and STENCIL in command buffer

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"
@@ skipping 88 matching lines @@
 
   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 &&
+    if (0 && 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 {
@@ skipping 141 matching lines @@
         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 &&
+    if (0 && 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,
@@ skipping 112 matching lines @@
       GLuint id = service_id();
       glDeleteFramebuffersEXT(1, &id);
     }
     manager_->StopTracking(this);
     manager_ = NULL;
   }
 }
 
 bool Framebuffer::HasUnclearedAttachment(
     GLenum attachment) const {
+  DCHECK(attachment != GL_DEPTH_STENCIL_ATTACHMENT);
   AttachmentMap::const_iterator it =
       attachments_.find(attachment);
   if (it != attachments_.end()) {
     const Attachment* attachment = it->second.get();
     return !attachment->cleared();
   }
   return false;
 }
 
 bool Framebuffer::HasUnclearedColorAttachments() const {
@@ skipping 143 matching lines @@
                                          attachment->level());
     }
   }
 }
 
 void Framebuffer::MarkAttachmentAsCleared(
     RenderbufferManager* renderbuffer_manager,
     TextureManager* texture_manager,
     GLenum attachment,
     bool cleared) {
+  DCHECK(attachment != GL_DEPTH_STENCIL_ATTACHMENT);
   AttachmentMap::iterator it = attachments_.find(attachment);
   if (it != attachments_.end()) {
     Attachment* a = it->second.get();
     if (a->cleared() != cleared) {
       a->SetCleared(renderbuffer_manager,
                     texture_manager,
                     cleared);
     }
   }
 }
 
 void Framebuffer::MarkAttachmentsAsCleared(
     RenderbufferManager* renderbuffer_manager,
     TextureManager* texture_manager,
     bool cleared) {
   for (AttachmentMap::iterator it = attachments_.begin();
        it != attachments_.end(); ++it) {
+    DCHECK(it->first != GL_DEPTH_STENCIL_ATTACHMENT);
     Attachment* attachment = it->second.get();
     if (attachment->cleared() != cleared) {
       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 19 matching lines @@
   // 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();
 }
 
 GLenum Framebuffer::GetDepthFormat() const {
-  auto iter = attachments_.find(GL_DEPTH_STENCIL_ATTACHMENT);
-  if (iter == attachments_.end())
-    iter = attachments_.find(GL_DEPTH_ATTACHMENT);
+  auto iter = attachments_.find(GL_DEPTH_ATTACHMENT);
   if (iter == attachments_.end())
     return 0;
   Attachment* attachment = iter->second.get();
   DCHECK(attachment);
   return attachment->internal_format();
 }
 
 GLenum Framebuffer::GetStencilFormat() const {
-  auto iter = attachments_.find(GL_DEPTH_STENCIL_ATTACHMENT);
-  if (iter == attachments_.end())
-    iter = attachments_.find(GL_STENCIL_ATTACHMENT);
+  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;
@@ skipping 239 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