Moves management of transients out of Window

ui/aura/window.h

 // 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.
 
 #ifndef UI_AURA_WINDOW_H_
 #define UI_AURA_WINDOW_H_
 
 #include <map>
 #include <string>
 #include <vector>
@@ skipping 24 matching lines @@
 class Transform;
 class Vector2d;
 }
 
 namespace ui {
 class EventHandler;
 class Layer;
 class Texture;
 }
 
+// TODO(sky): nuke. Temporary while moving transients out of Window.
+namespace views {
+namespace corewm {
+class TransientWindowManager;
+}
+}
 namespace aura {
 
 class LayoutManager;
 class RootWindow;
 class WindowDelegate;
 class WindowObserver;
 
 // TODO(beng): remove once RootWindow is renamed.
 typedef RootWindow WindowEventDispatcher;
 
@@ skipping 149 matching lines @@
 
   // Tree operations.
   void AddChild(Window* child);
   void RemoveChild(Window* child);
 
   const Windows& children() const { return children_; }
 
   // Returns true if this Window contains |other| somewhere in its children.
   bool Contains(const Window* other) const;
 
-  // Adds or removes |child| as a transient child of this window. Transient
-  // children get the following behavior:
-  // . The transient parent destroys any transient children when it is
-  //   destroyed. This means a transient child is destroyed if either its parent
-  //   or transient parent is destroyed.
-  // . If a transient child and its transient parent share the same parent, then
-  //   transient children are always ordered above the transient parent.
-  // Transient windows are typically used for popups and menus.
-  void AddTransientChild(Window* child);
-  void RemoveTransientChild(Window* child);
-
-  const Windows& transient_children() const { return transient_children_; }
-
-  Window* transient_parent() { return transient_parent_; }
-  const Window* transient_parent() const { return transient_parent_; }
-
   // Retrieves the first-level child with the specified id, or NULL if no first-
   // level child is found matching |id|.
   Window* GetChildById(int id);
   const Window* GetChildById(int id) const;
 
   // Converts |point| from |source|'s coordinates to |target|'s. If |source| is
   // NULL, the function returns without modifying |point|. |target| cannot be
   // NULL.
   static void ConvertPointToTarget(const Window* source,
                                    const Window* target,
@@ skipping 136 matching lines @@
   void PrintWindowHierarchy(int depth) const;
 #endif
 
  protected:
   // Deletes (or removes if not owned by parent) all child windows. Intended for
   // use from the destructor.
   void RemoveOrDestroyChildren();
 
  private:
   friend class test::WindowTestApi;
+  // TODO(sky): temporary until TransientWindowManager gets its own observer.
+  friend class views::corewm::TransientWindowManager;

[Ben Goodger (Google), 2013/12/18 00:32:38]

What's this used for? 

[sky, 2014/01/06 18:42:48]

WindowObserver has two methods related to transients: OnAddTransientChild and
OnRemoveTransientChild. In hopes of keeping this patch from spawling too much I
left those methods in WindowObserver. Since TransientWindowManager handles all
the transient logic now it has to be the place to notify the observers, hence
the friend. It's temporary though. After I land this I'll make
TransientWindowManager (or TransientWindowController) support an observer,
remove the two methods from WindowObserver and remove this friend.

   friend class LayoutManager;
   friend class RootWindow;
   friend class WindowTargeter;
 
   // Called by the public {Set,Get,Clear}Property functions.
   int64 SetPropertyInternal(const void* key,
                             const char* name,
                             PropertyDeallocator deallocator,
                             int64 value,
                             int64 default_value);
@@ skipping 42 matching lines @@
   // |parent| as well as updating bounds of windows with a layerless ancestor.
   void ReparentLayers(ui::Layer* parent, const gfx::Vector2d& offset);
 
   // Offsets the first encountered Windows with layers by |offset|. This
   // recurses through all layerless Windows, stopping at windows with layers.
   void OffsetLayerBounds(const gfx::Vector2d& offset);
 
   // Called when this window's parent has changed.
   void OnParentChanged();
 
-  // Returns true when |ancestor| is a transient ancestor of |this|.
-  bool HasTransientAncestor(const Window* ancestor) const;
-
-  // Adjusts |target| so that we don't attempt to stack on top of a window with
-  // a NULL delegate. See implementation for details.
-  void SkipNullDelegatesForStacking(StackDirection direction,
-                                    Window** target) const;
-
-  // Determines the real location for stacking |child| and invokes
-  // StackChildRelativeToImpl().
+  // The various stacking functions call into this to do the actual stacking.
   void StackChildRelativeTo(Window* child,
                             Window* target,
                             StackDirection direction);
 
-  // Implementation of StackChildRelativeTo().
-  void StackChildRelativeToImpl(Window* child,
-                                Window* target,
-                                StackDirection direction);
-
-  // Invoked from StackChildRelativeToImpl() to stack the layers appropriately
+  // Invoked from StackChildRelativeTo() to stack the layers appropriately
   // when stacking |child| relative to |target|.
   void StackChildLayerRelativeTo(Window* child,
                                  Window* target,
                                  StackDirection direction);
 
   // Called when this window's stacking order among its siblings is changed.
   void OnStackingChanged();
 
   // Notifies observers registered with this Window (and its subtree) when the
   // Window has been added or is about to be removed from a RootWindow.
@@ skipping 77 matching lines @@
   bool owned_by_parent_;
 
   WindowDelegate* delegate_;
 
   // The Window's parent.
   Window* parent_;
 
   // Child windows. Topmost is last.
   Windows children_;
 
-  // Transient windows.
-  Windows transient_children_;
-
-  Window* transient_parent_;
-
   // The visibility state of the window as set by Show()/Hide(). This may differ
   // from the visibility of the underlying layer, which may remain visible after
   // the window is hidden (e.g. to animate its disappearance).
   bool visible_;
 
   int id_;
   std::string name_;
 
   base::string16 title_;
 
@@ skipping 26 matching lines @@
   };
 
   std::map<const void*, Value> prop_map_;
 
   DISALLOW_COPY_AND_ASSIGN(Window);
 };
 
 }  // namespace aura
 
 #endif  // UI_AURA_WINDOW_H_