Makes visbility inherited. That is, in order for a window to be

ui/gfx/compositor/layer.cc

 // Copyright (c) 2011 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 "ui/gfx/compositor/layer.h"
 
 #include <algorithm>
 
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
@@ skipping 116 matching lines @@
 void Layer::SetOpacity(float opacity) {
   StopAnimatingIfNecessary(LayerAnimator::OPACITY);
   if (animator_.get() && animator_->IsRunning()) {
     animator_->AnimateOpacity(opacity);
     return;
   }
   SetOpacityImmediately(opacity);
 }
 
 void Layer::SetVisible(bool visible) {
+  if (visible_ == visible)
+    return;
+
+  bool was_drawn = IsDrawn();
   visible_ = visible;
-  if (!visible_)
+  bool is_drawn = IsDrawn();
+  if (was_drawn == is_drawn)
+    return;
+
+  if (!is_drawn)
     DropTextures();
   if (parent_)
     parent_->RecomputeHole();
 }
 
+bool Layer::IsDrawn() const {
+  const Layer* layer = this;
+  while (layer && layer->visible_)
+    layer = layer->parent_;
+  return layer == NULL;
+}
+
 bool Layer::ShouldDraw() {
   return type_ == LAYER_HAS_TEXTURE && GetCombinedOpacity() > 0.0f &&
       !hole_rect_.Contains(gfx::Rect(gfx::Point(0, 0), bounds_.size()));
 }
 
 // static
 void Layer::ConvertPointToLayer(const Layer* source,
                                 const Layer* target,
                                 gfx::Point* point) {
   const Layer* inner = NULL;
@@ skipping 129 matching lines @@
 
 void Layer::RecomputeHole() {
   if (type_ == LAYER_HAS_NO_TEXTURE)
     return;
 
   // Reset to default.
   hole_rect_ = gfx::Rect();
 
   // 1) We cannot do any hole punching if any child has a transform.
   for (size_t i = 0; i < children_.size(); ++i) {
-    if (children_[i]->transform().HasChange() && children_[i]->visible())
+    if (children_[i]->transform().HasChange() && children_[i]->visible_)
       return;
   }
 
   // 2) Find the largest hole.
   for (size_t i = 0; i < children_.size(); ++i) {
     // Ignore non-opaque and hidden children.
-    if (!children_[i]->IsCompletelyOpaque() || !children_[i]->visible())
+    if (!children_[i]->IsCompletelyOpaque() || !children_[i]->visible_)
       continue;
 
     if (children_[i]->bounds().size().GetArea() > hole_rect_.size().GetArea()) {
       hole_rect_ = children_[i]->bounds();
     }
   }
 
   // 3) Make sure hole does not intersect with non-opaque children.
   for (size_t i = 0; i < children_.size(); ++i) {
     // Ignore opaque and hidden children.
-    if (children_[i]->IsCompletelyOpaque() || !children_[i]->visible())
+    if (children_[i]->IsCompletelyOpaque() || !children_[i]->visible_)
       continue;
 
     // Ignore non-intersecting children.
     if (!hole_rect_.Intersects(children_[i]->bounds()))
       continue;
 
     // Compute surrounding fragments.
     std::vector<gfx::Rect> fragments;
     PunchHole(hole_rect_, children_[i]->bounds(), &fragments);
 
@@ skipping 156 matching lines @@
 
 void Layer::SetTransformFromAnimator(const Transform& transform) {
   SetTransformImmediately(transform);
 }
 
 void Layer::SetOpacityFromAnimator(float opacity) {
   SetOpacityImmediately(opacity);
 }
 
 }  // namespace ui