Make invalidateFramebuffer no-op for DEPTH_STENCIL attachment

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 30 matching lines @@
       bound_draw_framebuffer(NULL) {
 }
 
 DecoderFramebufferState::~DecoderFramebufferState() {
 }
 
 class RenderbufferAttachment
     : public Framebuffer::Attachment {
  public:
   explicit RenderbufferAttachment(
-      Renderbuffer* renderbuffer)
-      : renderbuffer_(renderbuffer) {
+      Renderbuffer* renderbuffer, GLenum attachment)
+      : renderbuffer_(renderbuffer),
+        attachment_(attachment) {
+    is_depth_stencil_ = renderbuffer ?
+      Framebuffer::IsDepthStencilFormat(internal_format()) : false;
   }
 
   GLsizei width() const override { return renderbuffer_->width(); }
 
   GLsizei height() const override { return renderbuffer_->height(); }
 
   GLenum internal_format() const override {
     return renderbuffer_->internal_format();
   }
 
   GLenum texture_type() const override {
     return TextureManager::ExtractTypeFromStorageFormat(
         renderbuffer_->internal_format());
   }
 
   GLsizei samples() const override { return renderbuffer_->samples(); }
 
   GLuint object_name() const override { return renderbuffer_->client_id(); }
 
-  bool cleared() const override { return renderbuffer_->cleared(); }
+  GLenum attachment() const override { return attachment_; }
+
+  bool IsDepthStencil() const override { return is_depth_stencil_; }
+
+  bool cleared() const override {
+    if (!is_depth_stencil_)
+      return renderbuffer_->cleared();
+    else
+      return renderbuffer_->cleared(attachment_);
+  }
 
   void SetCleared(RenderbufferManager* renderbuffer_manager,
                   TextureManager* /* texture_manager */,
                   bool cleared) override {
     DCHECK(renderbuffer_manager);
-    renderbuffer_manager->SetCleared(renderbuffer_.get(), cleared);
+    if (!is_depth_stencil_)
+      renderbuffer_manager->SetCleared(renderbuffer_.get(), cleared);
+    else
+      renderbuffer_manager->SetCleared(renderbuffer_.get(),
+                                       attachment_,
+                                       cleared);
   }
 
   bool IsPartiallyCleared() const override { return false; }
 
   bool IsTextureAttachment() const override { return false; }
   bool IsRenderbufferAttachment() const override { return true; }
 
   bool IsTexture(TextureRef* /* texture */) const override { return false; }
 
   bool IsRenderbuffer(Renderbuffer* renderbuffer) const override {
@@ skipping 43 matching lines @@
   }
 
   bool EmulatingRGB() const override { return false; }
 
  protected:
   ~RenderbufferAttachment() override {}
 
  private:
   scoped_refptr<Renderbuffer> renderbuffer_;
 
+  GLenum attachment_;
+  bool is_depth_stencil_;
+
   DISALLOW_COPY_AND_ASSIGN(RenderbufferAttachment);
 };
 
 class TextureAttachment
     : public Framebuffer::Attachment {
  public:
   TextureAttachment(
       TextureRef* texture_ref, GLenum target, GLint level,
-      GLsizei samples, GLint layer)
+      GLsizei samples, GLint layer, GLenum attachment)
       : texture_ref_(texture_ref),
         target_(target),
         level_(level),
         samples_(samples),
-        layer_(layer) {
+        layer_(layer),
+        attachment_(attachment) {
+    is_depth_stencil_ = texture_ref ?
+       Framebuffer::IsDepthStencilFormat(internal_format()) : false;
   }
 
   GLsizei width() const override {
     GLsizei temp_width = 0;
     GLsizei temp_height = 0;
     texture_ref_->texture()->GetLevelSize(
         target_, level_, &temp_width, &temp_height, nullptr);
     return temp_width;
   }
 
@@ skipping 24 matching lines @@
   GLsizei samples() const override { return samples_; }
 
   GLint layer() const { return layer_; }
 
   GLenum target() const { return target_; }
 
   GLint level() const { return level_; }
 
   GLuint object_name() const override { return texture_ref_->client_id(); }
 
+  GLenum attachment() const override { return attachment_; }
+
+  bool IsDepthStencil() const override { return is_depth_stencil_; }
+
   bool cleared() const override {
-    return texture_ref_->texture()->IsLevelCleared(target_, level_);
+    if (!is_depth_stencil_)
+      return texture_ref_->texture()->IsLevelCleared(target_, level_);
+    else
+      return texture_ref_->texture()->IsLevelCleared(target_, level_,
+                                                     attachment_);
   }
 
   void SetCleared(RenderbufferManager* /* renderbuffer_manager */,
                   TextureManager* texture_manager,
                   bool cleared) override {
     DCHECK(texture_manager);
-    texture_manager->SetLevelCleared(
-        texture_ref_.get(), target_, level_, cleared);
+    if (!is_depth_stencil_)
+      texture_manager->SetLevelCleared(
+          texture_ref_.get(), target_, level_, cleared);
+    else
+      texture_manager->SetLevelCleared(
+          texture_ref_.get(), target_, level_, attachment_, cleared);
   }
 
   bool IsPartiallyCleared() const override {
     return texture_ref_->texture()->IsLevelPartiallyCleared(target_, level_);
   }
 
   bool IsTextureAttachment() const override { return true; }
   bool IsRenderbufferAttachment() const override { return false; }
 
   bool IsTexture(TextureRef* texture) const override {
@@ skipping 76 matching lines @@
  protected:
   ~TextureAttachment() override {}
 
  private:
   scoped_refptr<TextureRef> texture_ref_;
   GLenum target_;
   GLint level_;
   GLsizei samples_;
   GLint layer_;
 
+  GLenum attachment_;
+  bool is_depth_stencil_;
+
   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),
@@ skipping 213 matching lines @@
       GLenum attachment,
       bool cleared) {
   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);
     }
+  } else if (attachment == GL_DEPTH_STENCIL_ATTACHMENT) {

[qiankun, 2016/07/14 06:48:21]

What about move the else branch out of MarkAttachmentAsCleared, i.e. to the
caller of MarkAttachmentAsCleared.

+    MarkAttachmentAsCleared(renderbuffer_manager, texture_manager,
+                            GL_DEPTH_ATTACHMENT, cleared);
+    MarkAttachmentAsCleared(renderbuffer_manager, texture_manager,
+                            GL_STENCIL_ATTACHMENT, cleared);
   }
 }
 
 void Framebuffer::MarkAttachmentsAsCleared(
       RenderbufferManager* renderbuffer_manager,
       TextureManager* texture_manager,
       bool cleared) {
   for (AttachmentMap::iterator it = attachments_.begin();
        it != attachments_.end(); ++it) {
     Attachment* attachment = it->second.get();
@@ skipping 168 matching lines @@
   GLenum result = glCheckFramebufferStatusEXT(target);
 
   if (result == GL_FRAMEBUFFER_COMPLETE) {
     manager_->GetFramebufferComboCompleteCache()->SetComplete(signature);
   }
 
   return result;
 }
 
 bool Framebuffer::IsCleared() const {
-  // are all the attachments cleaared?
+  // are all the attachments cleared?
   for (AttachmentMap::const_iterator it = attachments_.begin();
        it != attachments_.end(); ++it) {
     Attachment* attachment = it->second.get();
     if (!attachment->cleared()) {
       return false;
     }
   }
   return true;
 }
 
@@ skipping 102 matching lines @@
   }
 }
 
 void Framebuffer::AttachRenderbuffer(
     GLenum attachment, Renderbuffer* renderbuffer) {
   const Attachment* a = GetAttachment(attachment);
   if (a)
     a->DetachFromFramebuffer(this);
   if (renderbuffer) {
     attachments_[attachment] = scoped_refptr<Attachment>(
-        new RenderbufferAttachment(renderbuffer));
+        new RenderbufferAttachment(renderbuffer, attachment));
   } else {
     attachments_.erase(attachment);
   }
   framebuffer_complete_state_count_id_ = 0;
 }
 
 void Framebuffer::AttachTexture(
     GLenum attachment, TextureRef* texture_ref, GLenum target,
     GLint level, GLsizei samples) {
   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));
+        new TextureAttachment(texture_ref, target, level,
+                              samples, 0, attachment));
     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) {
   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));
+        new TextureAttachment(texture_ref, target, level,
+                              0, layer, attachment));
     texture_ref->texture()->AttachToFramebuffer();
   } else {
     attachments_.erase(attachment);
   }
   framebuffer_complete_state_count_id_ = 0;
 }
 
 const Framebuffer::Attachment*
     Framebuffer::GetAttachment(
         GLenum attachment) const {
@@ skipping 42 matching lines @@
 
 bool FramebufferManager::IsComplete(
     Framebuffer* framebuffer) {
   DCHECK(framebuffer);
   return framebuffer->framebuffer_complete_state_count_id() ==
       framebuffer_state_change_count_;
 }
 
 }  // namespace gles2
 }  // namespace gpu