Moves management of transients out of Window

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/bind.h"
 #include "base/bind_helpers.h"
 #include "base/callback.h"
 #include "base/logging.h"
-#include "base/stl_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "ui/aura/client/capture_client.h"
 #include "ui/aura/client/cursor_client.h"
 #include "ui/aura/client/event_client.h"
 #include "ui/aura/client/focus_client.h"
 #include "ui/aura/client/screen_position_client.h"
 #include "ui/aura/client/visibility_client.h"
 #include "ui/aura/client/window_stacking_client.h"
@@ skipping 187 matching lines @@
 
   DISALLOW_COPY_AND_ASSIGN(ScopedCursorHider);
 };
 
 Window::Window(WindowDelegate* delegate)
     : dispatcher_(NULL),
       type_(client::WINDOW_TYPE_UNKNOWN),
       owned_by_parent_(true),
       delegate_(delegate),
       parent_(NULL),
-      transient_parent_(NULL),
       visible_(false),
       id_(-1),
       transparent_(false),
       user_data_(NULL),
       ignore_events_(false),
       // Don't notify newly added observers during notification. This causes
       // problems for code that adds an observer as part of an observer
       // notification (such as the workspace code).
       observers_(ObserverList<WindowObserver>::NOTIFY_EXISTING_ONLY) {
   set_target_handler(delegate_);
@@ skipping 10 matching lines @@
   FOR_EACH_OBSERVER(WindowObserver, observers_, OnWindowDestroying(this));
 
   // Let the root know so that it can remove any references to us.
   WindowEventDispatcher* dispatcher = GetDispatcher();
   if (dispatcher)
     dispatcher->OnWindowDestroying(this);
 
   // Then destroy the children.
   RemoveOrDestroyChildren();
 
-  // Removes ourselves from our transient parent (if it hasn't been done by the
-  // RootWindow).
-  if (transient_parent_)
-    transient_parent_->RemoveTransientChild(this);
-
   // The window needs to be removed from the parent before calling the
   // WindowDestroyed callbacks of delegate and the observers.
   if (parent_)
     parent_->RemoveChild(this);
 
-  // Destroy transient children, only after we've removed ourselves from our
-  // parent, as destroying an active transient child may otherwise attempt to
-  // refocus us.
-  Windows transient_children(transient_children_);
-  STLDeleteElements(&transient_children);
-  DCHECK(transient_children_.empty());
-
-  // Delegate and observers need to be notified after transients are deleted.
   if (delegate_)
     delegate_->OnWindowDestroyed();
   ObserverListBase<WindowObserver>::Iterator iter(observers_);
   WindowObserver* observer;
   while ((observer = iter.GetNext())) {
     RemoveObserver(observer);
     observer->OnWindowDestroyed(this);
   }
 
   // Clear properties.
@@ skipping 104 matching lines @@
 const WindowEventDispatcher* Window::GetDispatcher() const {
   const Window* root_window = GetRootWindow();
   return root_window ? root_window->dispatcher_ : NULL;
 }
 
 void Window::Show() {
   SetVisible(true);
 }
 
 void Window::Hide() {
-  for (Windows::iterator it = transient_children_.begin();
-       it != transient_children_.end(); ++it) {
-    (*it)->Hide();
-  }
   SetVisible(false);
   ReleaseCapture();
 }
 
 bool Window::IsVisible() const {
   // Layer visibility can be inconsistent with window visibility, for example
   // when a Window is hidden, we want this function to return false immediately
   // after, even though the client may decide to animate the hide effect (and
   // so the layer will be visible for some time after Hide() is called).
   for (const Window* window = this; window; window = window->parent()) {
@@ skipping 190 matching lines @@
 }
 
 bool Window::Contains(const Window* other) const {
   for (const Window* parent = other; parent; parent = parent->parent_) {
     if (parent == this)
       return true;
   }
   return false;
 }
 
-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;
-  FOR_EACH_OBSERVER(WindowObserver, observers_,
-                    OnAddTransientChild(this, child));
-}
-
-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;
-  FOR_EACH_OBSERVER(WindowObserver, observers_,
-                    OnRemoveTransientChild(this, child));
-}
-
 Window* Window::GetChildById(int id) {
   return const_cast<Window*>(const_cast<const Window*>(this)->GetChildById(id));
 }
 
 const Window* Window::GetChildById(int id) const {
   Windows::const_iterator i;
   for (i = children_.begin(); i != children_.end(); ++i) {
     if ((*i)->id() == id)
       return *i;
     const Window* result = (*i)->GetChildById(id);
@@ skipping 513 matching lines @@
     layer_bounds += offset;
     layer_->SetBounds(layer_bounds);
   }
 }
 
 void Window::OnParentChanged() {
   FOR_EACH_OBSERVER(
       WindowObserver, observers_, OnWindowParentChanged(this, parent_));
 }
 
-bool Window::HasTransientAncestor(const Window* ancestor) const {
-  if (transient_parent_ == ancestor)
-    return true;
-  return transient_parent_ ?
-      transient_parent_->HasTransientAncestor(ancestor) : false;
-}
-
-void Window::SkipNullDelegatesForStacking(StackDirection direction,
-                                          Window** target) const {
-  DCHECK_EQ(this, (*target)->parent());
-  size_t target_i =
-      std::find(children_.begin(), children_.end(), *target) -
-      children_.begin();
-
-  // By convention we don't stack on top of windows with layers with NULL
-  // delegates.  Walk backward to find a valid target window.
-  // See tests WindowTest.StackingMadrigal and StackOverClosingTransient
-  // for an explanation of this.
-  while (target_i > 0) {
-    const size_t index = direction == STACK_ABOVE ? target_i : target_i - 1;
-    if (!children_[index]->layer_ ||
-        children_[index]->layer_->delegate() != NULL)
-      break;
-    --target_i;
-  }
-  *target = children_[target_i];
-}
-
 void Window::StackChildRelativeTo(Window* child,
                                   Window* target,
                                   StackDirection direction) {
   DCHECK_NE(child, target);
   DCHECK(child);
   DCHECK(target);
   DCHECK_EQ(this, child->parent());
   DCHECK_EQ(this, target->parent());
 
   client::WindowStackingClient* stacking_client =
       client::GetWindowStackingClient();
-  if (stacking_client)
-    stacking_client->AdjustStacking(&child, &target, &direction);
-
-  SkipNullDelegatesForStacking(direction, &target);
-
-  // If we couldn't find a valid target position, don't move anything.
-  if (direction == STACK_ABOVE &&
-      (target->layer_ && target->layer_->delegate() == NULL))
+  if (stacking_client &&
+      !stacking_client->AdjustStacking(&child, &target, &direction))
     return;
 
-  // Don't try to stack a child above itself.
-  if (child == target)
-    return;
-
-  // Move the child.
-  StackChildRelativeToImpl(child, target, direction);
-
-  // Stack any transient children that share the same parent to be in front of
-  // 'child'. Preserve the existing stacking order by iterating in the order
-  // those children appear in children_ array.
-  Window* last_transient = child;
-  Windows children(children_);
-  for (Windows::iterator it = children.begin(); it != children.end(); ++it) {
-    Window* transient_child = *it;
-    if (transient_child != last_transient &&
-        transient_child->HasTransientAncestor(child)) {
-      StackChildRelativeToImpl(transient_child, last_transient, STACK_ABOVE);
-      last_transient = transient_child;
-    }
-  }
-}
-
-void Window::StackChildRelativeToImpl(Window* child,
-                                      Window* target,
-                                      StackDirection direction) {
-  DCHECK_NE(child, target);
-  DCHECK(child);
-  DCHECK(target);
-  DCHECK_EQ(this, child->parent());
-  DCHECK_EQ(this, target->parent());
-
   const size_t child_i =
       std::find(children_.begin(), children_.end(), child) - children_.begin();
   const size_t target_i =
       std::find(children_.begin(), children_.end(), target) - children_.begin();
 
   // Don't move the child if it is already in the right place.
   if ((direction == STACK_ABOVE && child_i == target_i + 1) ||
       (direction == STACK_BELOW && child_i + 1 == target_i))
     return;
 
@@ skipping 305 matching lines @@
       return window;
     if (offset)
       *offset += window->bounds().OffsetFromOrigin();
   }
   if (offset)
     *offset = gfx::Vector2d();
   return NULL;
 }
 
 }  // namespace aura