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

ui/aura/window.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/aura/window.h"
 
 #include <algorithm>
 
 #include "base/logging.h"
 #include "ui/aura/desktop.h"
 #include "ui/aura/event.h"
 #include "ui/aura/event_filter.h"
 #include "ui/aura/focus_manager.h"
 #include "ui/aura/layout_manager.h"
 #include "ui/aura/window_delegate.h"
 #include "ui/base/animation/multi_animation.h"
 #include "ui/gfx/canvas_skia.h"
 #include "ui/gfx/compositor/compositor.h"
 #include "ui/gfx/compositor/layer.h"
 
 namespace aura {
 
 using internal::RootWindow;
 
 Window::Window(WindowDelegate* delegate)
     : delegate_(delegate),
-      visible_(false),
       parent_(NULL),
       id_(-1),
       user_data_(NULL) {
 }
 
 Window::~Window() {
   // Let the delegate know we're in the processing of destroying.
   if (delegate_)
     delegate_->OnWindowDestroying();
 
@@ skipping 15 matching lines @@
     delegate_->OnWindowDestroyed();
   if (parent_)
     parent_->RemoveChild(this);
 }
 
 void Window::Init() {
   ui::Layer::LayerType type = ui::Layer::LAYER_HAS_NO_TEXTURE;
   if (delegate_)
     type = ui::Layer::LAYER_HAS_TEXTURE;
   layer_.reset(new ui::Layer(Desktop::GetInstance()->compositor(), type));
+  // Windows (and therefor the layer) should initially be hidden.
+  layer_->SetVisible(false);

[Ben Goodger (Google), 2011/10/05 01:44:09]

therefore

also, I think we should make control-type windows initially visible. but we
don't have window types yet... so can you just drop a TODO here?

   layer_->set_delegate(this);
 }
 
 void Window::Show() {
   SetVisible(true);
 }
 
 void Window::Hide() {
   SetVisible(false);
   ReleaseCapture();
   if (Desktop::GetInstance()->active_window() == this ||
       !Desktop::GetInstance()->active_window()) {
     Desktop::GetInstance()->ActivateTopmostWindow();
   }
 }
 
+bool Window::IsVisible() const {
+  return layer_->IsDrawn();
+}
+
 void Window::SetLayoutManager(LayoutManager* layout_manager) {
   layout_manager_.reset(layout_manager);
 }
 
 void Window::SetBounds(const gfx::Rect& new_bounds) {
   // TODO: funnel this through the Desktop.
   gfx::Rect old_bounds = bounds();
   bool was_move = old_bounds.size() == new_bounds.size();
   layer_->SetBounds(new_bounds);
 
@@ skipping 109 matching lines @@
 bool Window::HitTest(const gfx::Point& point) {
   gfx::Rect local_bounds(gfx::Point(), bounds().size());
   // TODO(beng): hittest masks.
   return local_bounds.Contains(point);
 }
 
 Window* Window::GetEventHandlerForPoint(const gfx::Point& point) {
   Windows::const_reverse_iterator i = children_.rbegin();
   for (; i != children_.rend(); ++i) {
     Window* child = *i;
-    if (!child->visible())
+    if (!child->IsVisible())
       continue;
     gfx::Point point_in_child_coords(point);
     Window::ConvertPointToWindow(this, child, &point_in_child_coords);
     if (child->HitTest(point_in_child_coords)) {
       Window* handler = child->GetEventHandlerForPoint(point_in_child_coords);
       if (handler && handler->delegate())
         return handler;
     }
   }
   return delegate_ ? this : NULL;
 }
 
 internal::FocusManager* Window::GetFocusManager() {
   return parent_ ? parent_->GetFocusManager() : NULL;
 }
 
 void Window::SetCapture() {
-  if (!visible_)
+  if (!IsVisible())
     return;
 
   RootWindow* root = GetRoot();
   if (!root)
     return;
 
   root->SetCapture(this);
 }
 
 void Window::ReleaseCapture() {
@@ skipping 16 matching lines @@
   ui::MultiAnimation* multi_animation = new ui::MultiAnimation(parts);
   multi_animation->set_continuous(false);
   return multi_animation;
 }
 
 internal::RootWindow* Window::GetRoot() {
   return parent_ ? parent_->GetRoot() : NULL;
 }
 
 void Window::SetVisible(bool visible) {
-  if (visible_ == visible)
-    return;
-
-  visible_ = visible;
-  layer_->SetVisible(visible_);
-  SchedulePaint();
+  bool was_visible = IsVisible();
+  layer_->SetVisible(visible);
+  bool is_visible = IsVisible();
+  if (was_visible != is_visible)
+    SchedulePaint();
 }
 
 void Window::SchedulePaint() {
   SchedulePaintInRect(gfx::Rect(0, 0, bounds().width(), bounds().height()));
 }
 
 void Window::OnPaintLayer(gfx::Canvas* canvas) {
   delegate_->OnPaint(canvas);
 }
 
 }  // namespace aura