Adds two new observer methods to allow code to be notified when a Window is added/removed from a ...

ui/aura/window.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 "ui/aura/window.h"
 
 #include <algorithm>
 
 #include "base/logging.h"
 #include "base/stl_util.h"
@@ skipping 276 matching lines @@
 
   layer_->Add(child->layer_);
 
   children_.push_back(child);
   if (layout_manager_.get())
     layout_manager_->OnWindowAddedToLayout(child);
   FOR_EACH_OBSERVER(WindowObserver, observers_, OnWindowAdded(child));
   child->OnParentChanged();
 
   RootWindow* root_window = child->GetRootWindow();
-  if (root_window)
-    root_window->OnWindowAttachedToRootWindow(child);
+  if (root_window) {
+    root_window->OnWindowAddedToRootWindow(child);
+    NotifyAddedToRootWindow();
+  }
 }
 
 void Window::AddTransientChild(Window* child) {
   if (child->transient_parent_)
     child->transient_parent_->RemoveTransientChild(child);
   DCHECK(std::find(transient_children_.begin(), transient_children_.end(),
                    child) == transient_children_.end());
   transient_children_.push_back(child);
   child->transient_parent_ = this;
 }
 
 void Window::RemoveTransientChild(Window* child) {
   Windows::iterator i =
       std::find(transient_children_.begin(), transient_children_.end(), child);
   DCHECK(i != transient_children_.end());
   transient_children_.erase(i);
   if (child->transient_parent_ == this)
     child->transient_parent_ = NULL;
 }
 
 void Window::RemoveChild(Window* child) {
   Windows::iterator i = std::find(children_.begin(), children_.end(), child);
   DCHECK(i != children_.end());
   if (layout_manager_.get())
     layout_manager_->OnWillRemoveWindowFromLayout(child);
   FOR_EACH_OBSERVER(WindowObserver, observers_, OnWillRemoveWindow(child));
   RootWindow* root_window = child->GetRootWindow();
-  if (root_window)
-    root_window->OnWindowDetachingFromRootWindow(child);
+  if (root_window) {
+    root_window->OnWindowRemovedFromRootWindow(child);
+    child->NotifyRemovingFromRootWindow();
+  }
   child->parent_ = NULL;
   // We should only remove the child's layer if the child still owns that layer.
   // Someone else may have acquired ownership of it via AcquireLayer() and may
   // expect the hierarchy to go unchanged as the Window is destroyed.
   if (child->layer_owner_.get())
     layer_->Remove(child->layer_);
   children_.erase(i);
   child->OnParentChanged();
 }
 
@@ skipping 174 matching lines @@
 
 bool Window::StopsEventPropagation() const {
   if (!stops_event_propagation_ || children_.empty())
     return false;
   aura::Window::Windows::const_iterator it =
       std::find_if(children_.begin(), children_.end(),
                    std::mem_fun(&aura::Window::IsVisible));
   return it != children_.end();
 }
 
-void Window::OnWindowDetachingFromRootWindow(aura::Window* window) {
-}
-
-void Window::OnWindowAttachedToRootWindow(aura::Window* window) {
-}
-
 void Window::SetBoundsInternal(const gfx::Rect& new_bounds) {
   gfx::Rect actual_new_bounds(new_bounds);
 
   // Ensure we don't go smaller than our minimum bounds.
   if (delegate_) {
     const gfx::Size& min_size = delegate_->GetMinimumSize();
     actual_new_bounds.set_width(
         std::max(min_size.width(), actual_new_bounds.width()));
     actual_new_bounds.set_height(
         std::max(min_size.height(), actual_new_bounds.height()));
@@ skipping 98 matching lines @@
 
 void Window::OnParentChanged() {
   FOR_EACH_OBSERVER(
       WindowObserver, observers_, OnWindowParentChanged(this, parent_));
 }
 
 void Window::OnStackingChanged() {
   FOR_EACH_OBSERVER(WindowObserver, observers_, OnWindowStackingChanged(this));
 }
 
+void Window::NotifyRemovingFromRootWindow() {
+  FOR_EACH_OBSERVER(WindowObserver, observers_,
+                    OnWindowRemovingFromRootWindow(this));
+  for (Window::Windows::const_iterator it = children_.begin();
+       it != children_.end(); ++it) {
+    (*it)->NotifyRemovingFromRootWindow();
+  }
+}
+
+void Window::NotifyAddedToRootWindow() {
+  FOR_EACH_OBSERVER(WindowObserver, observers_,
+                    OnWindowAddedToRootWindow(this));
+  for (Window::Windows::const_iterator it = children_.begin();
+       it != children_.end(); ++it) {
+    (*it)->NotifyAddedToRootWindow();
+  }
+}
+
 void Window::OnPaintLayer(gfx::Canvas* canvas) {
   if (delegate_)
     delegate_->OnPaint(canvas);
 }
 
 void Window::UpdateLayerName(const std::string& name) {
 #if !defined(NDEBUG)
   DCHECK(layer());
 
   std::string layer_name(name_);
@@ skipping 14 matching lines @@
                                         parent_->children().end(),
                                         this);
   for (++i; i != parent_->children().end(); ++i) {
     if ((*i)->StopsEventPropagation())
       return true;
   }
   return false;
 }
 
 }  // namespace aura