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

ui/gfx/compositor/layer_unittest.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 "base/basictypes.h"
 #include "base/compiler_specific.h"
 #include "base/memory/scoped_ptr.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/gfx/canvas_skia.h"
 #include "ui/gfx/compositor/compositor_observer.h"
 #include "ui/gfx/compositor/layer.h"
 #include "ui/gfx/compositor/test_compositor.h"
 #include "ui/gfx/compositor/test_compositor_host.h"
 
 namespace ui {
 
 namespace {
 
-// Use
+// There are three test classes in here that configure the Compositor and
+// Layer's slightly differently:
+// - LayerWithNullDelegateTest uses TestCompositor and NullLayerDelegate as the
+//   LayerDelegate. This is typically the base class you want to use.
+// - LayerWithDelegateTest uses TestCompositor and does not set a LayerDelegate
+//   on the delegates.
 // - LayerWithRealCompositorTest when a real compositor is required for testing.
-//    - Slow because they bring up a window.
-//
-// - LayerWithDelegateTest for testing functionality of the LayerDelegate.
-// - LayerWithNullDelegateTest for testing all other functionality.
-
+//    - Slow because they bring up a window and run the real compositor. This
+//      is typically not what you want.
 class LayerWithRealCompositorTest : public testing::Test {
  public:
   LayerWithRealCompositorTest() {}
   virtual ~LayerWithRealCompositorTest() {}
 
   // Overridden from testing::Test:
   virtual void SetUp() OVERRIDE {
     const gfx::Rect host_bounds(10, 10, 500, 500);
     window_.reset(TestCompositorHost::Create(host_bounds));
     window_->Show();
@@ skipping 580 matching lines @@
   EXPECT_TRUE(NULL != l121->texture());
   EXPECT_TRUE(NULL != l122->texture());
 
   // Toggling l2's visibility should drop all sub-layer textures.
   l12->SetVisible(false);
   EXPECT_EQ(NULL, l12->texture());
   EXPECT_EQ(NULL, l121->texture());
   EXPECT_EQ(NULL, l122->texture());
 }
 
+// Various visibile/drawn assertions.
+TEST_F(LayerWithNullDelegateTest, Visibility) {
+  scoped_ptr<Layer> l1(new Layer(NULL, Layer::LAYER_HAS_TEXTURE));
+  scoped_ptr<Layer> l2(new Layer(NULL, Layer::LAYER_HAS_TEXTURE));
+  scoped_ptr<Layer> l3(new Layer(NULL, Layer::LAYER_HAS_TEXTURE));
+  l1->Add(l2.get());
+  l2->Add(l3.get());
+
+  NullLayerDelegate delegate;
+  l1->set_delegate(&delegate);
+  l2->set_delegate(&delegate);
+  l3->set_delegate(&delegate);
+
+  // Layers should initially be drawn.
+  EXPECT_TRUE(l1->IsDrawn());
+  EXPECT_TRUE(l2->IsDrawn());
+  EXPECT_TRUE(l3->IsDrawn());
+
+  compositor()->SetRootLayer(l1.get());
+
+  Draw();
+
+  l1->SetVisible(false);
+  EXPECT_FALSE(l1->IsDrawn());
+  EXPECT_FALSE(l2->IsDrawn());
+  EXPECT_FALSE(l3->IsDrawn());
+
+  l3->SetVisible(false);
+  EXPECT_FALSE(l1->IsDrawn());
+  EXPECT_FALSE(l2->IsDrawn());
+  EXPECT_FALSE(l3->IsDrawn());
+
+  l1->SetVisible(true);
+  EXPECT_TRUE(l1->IsDrawn());
+  EXPECT_TRUE(l2->IsDrawn());
+  EXPECT_FALSE(l3->IsDrawn());
+}
+
 } // namespace ui