Make invalidateFramebuffer no-op for DEPTH_STENCIL attachment

gpu/command_buffer/service/texture_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/texture_manager.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
@@ skipping 785 matching lines @@
   size_t face_index = GLES2Util::GLTargetToFaceIndex(target);
   DCHECK_LT(static_cast<size_t>(face_index), face_infos_.size());
   DCHECK_LT(static_cast<size_t>(level),
             face_infos_[face_index].level_infos.size());
   Texture::LevelInfo& info = face_infos_[face_index].level_infos[level];
   UpdateMipCleared(&info, info.width, info.height,
                    cleared ? gfx::Rect(info.width, info.height) : gfx::Rect());
   UpdateCleared();
 }
 
+void Texture::SetLevelCleared(GLenum target,
+                              GLint level,
+                              GLenum attachment,
+                              bool cleared) {
+  DCHECK_GE(level, 0);
+  // Only take effect when the format is DEPTH_STENCIL
+  size_t face_index = GLES2Util::GLTargetToFaceIndex(target);
+  DCHECK_LT(static_cast<size_t>(face_index), face_infos_.size());
+  DCHECK_LT(static_cast<size_t>(level),
+            face_infos_[face_index].level_infos.size());
+  Texture::LevelInfo& info = face_infos_[face_index].level_infos[level];
+  if (info.format != GL_DEPTH_STENCIL)

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

Will this be true in any conditions? I think only DEPTH/STENCIL attachment can
execute this path in your current implementation.

+    return;
+  // cleared_ is true only when both depth and stencil part are cleared.
+  if (attachment == GL_DEPTH_ATTACHMENT) {
+    if (cleared  == stencil_cleared_) {
+      // SetLevelCleared(target, level, cleared);

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

remove unused code.

+      UpdateMipCleared(&info, info.width, info.height,
+                       cleared ? gfx::Rect(info.width, info.height) :
+                                 gfx::Rect());
+      UpdateCleared();
+    } else {
+      // SetLevelCleared(target, level, false);
+      UpdateMipCleared(&info, info.width, info.height, gfx::Rect());
+      UpdateCleared();
+      depth_cleared_ = cleared;
+      stencil_cleared_ = !cleared;

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

Should depth_cleared_ be updated in if branch?
stencil_cleared_ already equals !cleared. The assignment doesn't change
anything.

+    }
+  }
+  else if (attachment == GL_STENCIL_ATTACHMENT) {
+    if (cleared == depth_cleared_) {
+      // SetLevelCleared(target, level, cleared);
+      UpdateMipCleared(&info, info.width, info.height,
+                       cleared ? gfx::Rect(info.width, info.height) :
+                                 gfx::Rect());
+      UpdateCleared();
+    } else {
+      // SetLevelCleared(target, level, false);
+      UpdateMipCleared(&info, info.width, info.height, gfx::Rect());
+      UpdateCleared();
+      stencil_cleared_ = cleared;
+      depth_cleared_ = !cleared;

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

Same here.

+    }
+  }
+}
+
 void Texture::UpdateCleared() {
   if (face_infos_.empty()) {
     return;
   }
 
   const bool cleared = (num_uncleared_mips_ == 0);
 
   // If texture is uncleared and is attached to a framebuffer,
   // that framebuffer must be marked possibly incomplete.
   if (!cleared && IsAttachedToFramebuffer()) {
     IncAllFramebufferStateChangeCount();
   }
 
   UpdateSafeToRenderFrom(cleared);
 }
 
 void Texture::UpdateSafeToRenderFrom(bool cleared) {
   if (cleared_ == cleared)
     return;
   cleared_ = cleared;
   int delta = cleared ? -1 : +1;
   for (RefSet::iterator it = refs_.begin(); it != refs_.end(); ++it)
     (*it)->manager()->UpdateSafeToRenderFrom(delta);
+
+  depth_cleared_ = cleared;
+  stencil_cleared_ = cleared;
 }
 
 void Texture::UpdateMipCleared(LevelInfo* info,
                                GLsizei width,
                                GLsizei height,
                                const gfx::Rect& cleared_rect) {
   bool was_cleared = info->cleared_rect == gfx::Rect(info->width, info->height);
   info->width = width;
   info->height = height;
   info->cleared_rect = cleared_rect;
@@ skipping 557 matching lines @@
   size_t face_index = GLES2Util::GLTargetToFaceIndex(target);
   if (face_index >= face_infos_.size() ||
       level < 0 ||
       level >= static_cast<GLint>(face_infos_[face_index].level_infos.size())) {
     return true;
   }
   const Texture::LevelInfo& info = face_infos_[face_index].level_infos[level];
   return info.cleared_rect == gfx::Rect(info.width, info.height);
 }
 
+bool Texture::IsLevelCleared(GLenum target,
+                             GLint level,
+                             GLenum attachment) const {

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

ASSERT(attachment == GL_DEPTH_ATTACHMENT || attachment ==
GL_STENCIL_ATTACHMENT);

+  size_t face_index = GLES2Util::GLTargetToFaceIndex(target);
+  if (face_index >= face_infos_.size() ||
+      level < 0 ||
+      level >= static_cast<GLint>(face_infos_[face_index].level_infos.size())) {
+    return true;
+  }
+  const Texture::LevelInfo& info = face_infos_[face_index].level_infos[level];
+  if (info.format != GL_DEPTH_STENCIL)
+    return info.cleared_rect == gfx::Rect(info.width, info.height);
+  if (attachment == GL_DEPTH_ATTACHMENT)
+    return depth_cleared_;
+  else if (attachment == GL_STENCIL_ATTACHMENT)
+    return stencil_cleared_;
+  // Should not be reached
+  return info.cleared_rect == gfx::Rect(info.width, info.height);

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

change to return attachment == GL_DEPTH_ATTACHMEN ? depth_cleared_ :
stencil_cleared_.

+}
+
 bool Texture::IsLevelPartiallyCleared(GLenum target, GLint level) const {
   size_t face_index = GLES2Util::GLTargetToFaceIndex(target);
   if (face_index >= face_infos_.size() ||
       level < 0 ||
       level >= static_cast<GLint>(face_infos_[face_index].level_infos.size())) {
     return false;
   }
   const Texture::LevelInfo& info = face_infos_[face_index].level_infos[level];
   return (info.cleared_rect != gfx::Rect(info.width, info.height) &&
           info.cleared_rect != gfx::Rect());
@@ skipping 484 matching lines @@
 }
 
 void TextureManager::SetLevelCleared(TextureRef* ref,
                                      GLenum target,
                                      GLint level,
                                      bool cleared) {
   DCHECK(ref);
   ref->texture()->SetLevelCleared(target, level, cleared);
 }
 
+void TextureManager::SetLevelCleared(TextureRef* ref,
+                                     GLenum target,
+                                     GLint level,
+                                     GLenum attachment,
+                                     bool cleared) {
+  DCHECK(ref);
+  ref->texture()->SetLevelCleared(target, level, attachment, cleared);
+}
+
 bool TextureManager::ClearRenderableLevels(
     GLES2Decoder* decoder, TextureRef* ref) {
   DCHECK(ref);
   return ref->texture()->ClearRenderableLevels(decoder);
 }
 
 bool TextureManager::ClearTextureLevel(
     GLES2Decoder* decoder, TextureRef* ref,
     GLenum target, GLint level) {
   DCHECK(ref);
@@ skipping 1444 matching lines @@
 uint32_t TextureManager::GetServiceIdGeneration() const {
   return current_service_id_generation_;
 }
 
 void TextureManager::IncrementServiceIdGeneration() {
   current_service_id_generation_++;
 }
 
 }  // namespace gles2
 }  // namespace gpu