Adds OnChildWindowVisibilityChanged to ui::WindowObserver

services/ui/public/cpp/window.cc

 // Copyright 2014 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 "services/ui/public/cpp/window.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <set>
@@ skipping 714 matching lines @@
   FOR_EACH_OBSERVER(WindowObserver, observers_, OnWindowDrawnChanging(this));
   parent_drawn_ = value;
   FOR_EACH_OBSERVER(WindowObserver, observers_, OnWindowDrawnChanged(this));
 }
 
 void Window::LocalSetVisible(bool visible) {
   if (visible_ == visible)
     return;
 
   FOR_EACH_OBSERVER(WindowObserver, observers_,
-                    OnWindowVisibilityChanging(this));
+                    OnWindowVisibilityChanging(this, visible));
   visible_ = visible;
-  NotifyWindowVisibilityChanged(this);
+  if (parent_) {
+    FOR_EACH_OBSERVER(WindowObserver, parent_->observers_,
+                      OnChildWindowVisibilityChanged(this, visible));
+  }
+
+  NotifyWindowVisibilityChanged(this, visible);
 }
 
 void Window::LocalSetOpacity(float opacity) {
   if (opacity_ == opacity)
     return;
 
   float old_opacity = opacity_;
   opacity_ = opacity;
   FOR_EACH_OBSERVER(WindowObserver, observers_,
                     OnWindowOpacityChanged(this, old_opacity, opacity_));
@@ skipping 42 matching lines @@
         parent()->children().begin(), parent()->children().end(), this);
     DCHECK(window_i != parent()->children().end());
     if (window_i != parent()->children().begin() &&
         (*(window_i - 1) == stacking_target_))
       return;
   }
   RestackTransientDescendants(this, &GetStackingTarget,
                               &ReorderWithoutNotification);
 }
 
-void Window::NotifyWindowVisibilityChanged(Window* target) {
-  if (!NotifyWindowVisibilityChangedDown(target)) {
+void Window::NotifyWindowVisibilityChanged(Window* target, bool visible) {
+  if (!NotifyWindowVisibilityChangedDown(target, visible))
     return;  // |this| has been deleted.
-  }
-  NotifyWindowVisibilityChangedUp(target);
+
+  NotifyWindowVisibilityChangedUp(target, visible);
 }
 
-bool Window::NotifyWindowVisibilityChangedAtReceiver(Window* target) {
+bool Window::NotifyWindowVisibilityChangedAtReceiver(Window* target,
+                                                     bool visible) {
   // |this| may be deleted during a call to OnWindowVisibilityChanged() on one
   // of the observers. We create an local observer for that. In that case we
   // exit without further access to any members.
   WindowTracker tracker;
   tracker.Add(this);
   FOR_EACH_OBSERVER(WindowObserver, observers_,
-                    OnWindowVisibilityChanged(target));
+                    OnWindowVisibilityChanged(target, visible));
   return tracker.Contains(this);
 }
 
-bool Window::NotifyWindowVisibilityChangedDown(Window* target) {
-  if (!NotifyWindowVisibilityChangedAtReceiver(target))
+bool Window::NotifyWindowVisibilityChangedDown(Window* target, bool visible) {
+  if (!NotifyWindowVisibilityChangedAtReceiver(target, visible))
     return false;  // |this| was deleted.
   std::set<const Window*> child_already_processed;
   bool child_destroyed = false;
   do {
     child_destroyed = false;
     for (Window::Children::const_iterator it = children_.begin();
          it != children_.end(); ++it) {
       if (!child_already_processed.insert(*it).second)
         continue;
-      if (!(*it)->NotifyWindowVisibilityChangedDown(target)) {
+      if (!(*it)->NotifyWindowVisibilityChangedDown(target, visible)) {
         // |*it| was deleted, |it| is invalid and |children_| has changed.  We
         // exit the current for-loop and enter a new one.
         child_destroyed = true;
         break;
       }
     }
   } while (child_destroyed);
   return true;
 }
 
-void Window::NotifyWindowVisibilityChangedUp(Window* target) {
+void Window::NotifyWindowVisibilityChangedUp(Window* target, bool visible) {
   // Start with the parent as we already notified |this|
   // in NotifyWindowVisibilityChangedDown.
   for (Window* window = parent(); window; window = window->parent()) {
-    bool ret = window->NotifyWindowVisibilityChangedAtReceiver(target);
+    bool ret = window->NotifyWindowVisibilityChangedAtReceiver(target, visible);
     DCHECK(ret);
   }
 }
 
 bool Window::PrepareForEmbed() {
   if (!WasCreatedByThisClient())
     return false;
 
   while (!children_.empty())
     RemoveChild(children_[0]);
@@ skipping 68 matching lines @@
     notifier->NotifyWindowReordered();
 
   return true;
 }
 
 // static
 Window** Window::GetStackingTarget(Window* window) {
   return &window->stacking_target_;
 }
 }  // namespace ui