It is time.

ui/aura/window.h

Index: ui/aura/window.h
diff --git a/ui/aura/window.h b/ui/aura/window.h
deleted file mode 100644
index cb2397c0a2716d1a5383128accbb3e0e08557a22..0000000000000000000000000000000000000000
--- a/ui/aura/window.h
+++ /dev/null
@@ -1,549 +0,0 @@
-// 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>
-
-#include "base/basictypes.h"
-#include "base/compiler_specific.h"
-#include "base/memory/scoped_ptr.h"
-#include "base/observer_list.h"
-#include "base/strings/string16.h"
-#include "ui/aura/aura_export.h"
-#include "ui/aura/window_layer_type.h"
-#include "ui/aura/window_observer.h"
-#include "ui/compositor/layer_animator.h"
-#include "ui/compositor/layer_delegate.h"
-#include "ui/compositor/layer_owner.h"
-#include "ui/events/event_constants.h"
-#include "ui/events/event_target.h"
-#include "ui/events/event_targeter.h"
-#include "ui/events/gestures/gesture_types.h"
-#include "ui/gfx/insets.h"
-#include "ui/gfx/native_widget_types.h"
-#include "ui/gfx/rect.h"
-#include "ui/wm/public/window_types.h"
-
-namespace gfx {
-class Display;
-class Transform;
-class Vector2d;
-}
-
-namespace ui {
-class EventHandler;
-class Layer;
-class Texture;
-}
-
-namespace aura {
-
-class LayoutManager;
-class WindowDelegate;
-class WindowObserver;
-class WindowTreeHost;
-
-// Defined in window_property.h (which we do not include)
-template<typename T>
-struct WindowProperty;
-
-namespace test {
-class WindowTestApi;
-}
-
-// Aura window implementation. Interesting events are sent to the
-// WindowDelegate.
-// TODO(beng): resolve ownership.
-class AURA_EXPORT Window : public ui::LayerDelegate,
-                           public ui::LayerOwner,
-                           public ui::EventTarget,
-                           public ui::GestureConsumer {
- public:
-  // Used when stacking windows.
-  enum StackDirection {
-    STACK_ABOVE,
-    STACK_BELOW
-  };
-
-  typedef std::vector<Window*> Windows;
-
-  explicit Window(WindowDelegate* delegate);
-  ~Window() override;
-
-  // Initializes the window. This creates the window's layer.
-  void Init(WindowLayerType layer_type);
-
-  void set_owned_by_parent(bool owned_by_parent) {
-    owned_by_parent_ = owned_by_parent;
-  }
-  bool owned_by_parent() const { return owned_by_parent_; }
-
-  // A type is used to identify a class of Windows and customize behavior such
-  // as event handling and parenting.  This field should only be consumed by the
-  // shell -- Aura itself shouldn't contain type-specific logic.
-  ui::wm::WindowType type() const { return type_; }
-  void SetType(ui::wm::WindowType type);
-
-  int id() const { return id_; }
-  void set_id(int id) { id_ = id; }
-
-  const std::string& name() const { return name_; }
-  void SetName(const std::string& name);
-
-  const base::string16 title() const { return title_; }
-  void SetTitle(const base::string16& title);
-
-  bool transparent() const { return transparent_; }
-  void SetTransparent(bool transparent);
-
-  // See description in Layer::SetFillsBoundsCompletely.
-  void SetFillsBoundsCompletely(bool fills_bounds);
-
-  WindowDelegate* delegate() { return delegate_; }
-  const WindowDelegate* delegate() const { return delegate_; }
-
-  const gfx::Rect& bounds() const { return bounds_; }
-
-  Window* parent() { return parent_; }
-  const Window* parent() const { return parent_; }
-
-  // Returns the root Window that contains this Window. The root Window is
-  // defined as the Window that has a dispatcher. These functions return NULL if
-  // the Window is contained in a hierarchy that does not have a dispatcher at
-  // its root.
-  Window* GetRootWindow();
-  const Window* GetRootWindow() const;
-
-  WindowTreeHost* GetHost();
-  const WindowTreeHost* GetHost() const;
-  void set_host(WindowTreeHost* host) { host_ = host; }
-  bool IsRootWindow() const { return !!host_; }
-
-  // The Window does not own this object.
-  void set_user_data(void* user_data) { user_data_ = user_data; }
-  void* user_data() const { return user_data_; }
-
-  // Changes the visibility of the window.
-  void Show();
-  void Hide();
-  // Returns true if this window and all its ancestors are visible.
-  bool IsVisible() const;
-  // Returns the visibility requested by this window. IsVisible() takes into
-  // account the visibility of the layer and ancestors, where as this tracks
-  // whether Show() without a Hide() has been invoked.
-  bool TargetVisibility() const { return visible_; }
-
-  // Returns the window's bounds in root window's coordinates.
-  gfx::Rect GetBoundsInRootWindow() const;
-
-  // Returns the window's bounds in screen coordinates.
-  // How the root window's coordinates is mapped to screen's coordinates
-  // is platform dependent and defined in the implementation of the
-  // |aura::client::ScreenPositionClient| interface.
-  gfx::Rect GetBoundsInScreen() const;
-
-  void SetTransform(const gfx::Transform& transform);
-
-  // Assigns a LayoutManager to size and place child windows.
-  // The Window takes ownership of the LayoutManager.
-  void SetLayoutManager(LayoutManager* layout_manager);
-  LayoutManager* layout_manager() { return layout_manager_.get(); }
-
-  // Sets a new event-targeter for the window, and returns the previous
-  // event-targeter.
-  scoped_ptr<ui::EventTargeter> SetEventTargeter(
-      scoped_ptr<ui::EventTargeter> targeter);
-
-  // Changes the bounds of the window. If present, the window's parent's
-  // LayoutManager may adjust the bounds.
-  void SetBounds(const gfx::Rect& new_bounds);
-
-  // Changes the bounds of the window in the screen coordintates.
-  // If present, the window's parent's LayoutManager may adjust the bounds.
-  void SetBoundsInScreen(const gfx::Rect& new_bounds_in_screen_coords,
-                         const gfx::Display& dst_display);
-
-  // Returns the target bounds of the window. If the window's layer is
-  // not animating, it simply returns the current bounds.
-  gfx::Rect GetTargetBounds() const;
-
-  // Marks the a portion of window as needing to be painted.
-  void SchedulePaintInRect(const gfx::Rect& rect);
-
-  // Stacks the specified child of this Window at the front of the z-order.
-  void StackChildAtTop(Window* child);
-
-  // Stacks |child| above |target|.  Does nothing if |child| is already above
-  // |target|.  Does not stack on top of windows with NULL layer delegates,
-  // see WindowTest.StackingMadrigal for details.
-  void StackChildAbove(Window* child, Window* target);
-
-  // Stacks the specified child of this window at the bottom of the z-order.
-  void StackChildAtBottom(Window* child);
-
-  // Stacks |child| below |target|. Does nothing if |child| is already below
-  // |target|.
-  void StackChildBelow(Window* child, Window* target);
-
-  // 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;
-
-  // 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,
-                                   gfx::Point* point);
-  static void ConvertRectToTarget(const Window* source,
-                                  const Window* target,
-                                  gfx::Rect* rect);
-
-  // Moves the cursor to the specified location relative to the window.
-  void MoveCursorTo(const gfx::Point& point_in_window);
-
-  // Returns the cursor for the specified point, in window coordinates.
-  gfx::NativeCursor GetCursor(const gfx::Point& point) const;
-
-  // Add/remove observer.
-  void AddObserver(WindowObserver* observer);
-  void RemoveObserver(WindowObserver* observer);
-  bool HasObserver(WindowObserver* observer);
-
-  void set_ignore_events(bool ignore_events) { ignore_events_ = ignore_events; }
-  bool ignore_events() const { return ignore_events_; }
-
-  // Sets the window to grab hits for an area extending |insets| pixels inside
-  // its bounds (even if that inner region overlaps a child window). This can be
-  // used to create an invisible non-client area that overlaps the client area.
-  void set_hit_test_bounds_override_inner(const gfx::Insets& insets) {
-    hit_test_bounds_override_inner_ = insets;
-  }
-  gfx::Insets hit_test_bounds_override_inner() const {
-    return hit_test_bounds_override_inner_;
-  }
-
-  // Returns true if the |point_in_root| in root window's coordinate falls
-  // within this window's bounds. Returns false if the window is detached
-  // from root window.
-  bool ContainsPointInRoot(const gfx::Point& point_in_root) const;
-
-  // Returns true if relative-to-this-Window's-origin |local_point| falls
-  // within this Window's bounds.
-  bool ContainsPoint(const gfx::Point& local_point) const;
-
-  // Returns the Window that most closely encloses |local_point| for the
-  // purposes of event targeting.
-  Window* GetEventHandlerForPoint(const gfx::Point& local_point);
-
-  // Returns the topmost Window with a delegate containing |local_point|.
-  Window* GetTopWindowContainingPoint(const gfx::Point& local_point);
-
-  // Returns this window's toplevel window (the highest-up-the-tree anscestor
-  // that has a delegate set).  The toplevel window may be |this|.
-  Window* GetToplevelWindow();
-
-  // Claims or relinquishes the claim to focus.
-  void Focus();
-  void Blur();
-
-  // Returns true if the Window is currently the focused window.
-  bool HasFocus() const;
-
-  // Returns true if the Window can be focused.
-  bool CanFocus() const;
-
-  // Returns true if the Window can receive events.
-  bool CanReceiveEvents() const;
-
-  // Does a capture on the window. This does nothing if the window isn't showing
-  // (VISIBILITY_SHOWN) or isn't contained in a valid window hierarchy.
-  void SetCapture();
-
-  // Releases a capture.
-  void ReleaseCapture();
-
-  // Returns true if this window has capture.
-  bool HasCapture();
-
-  // Suppresses painting window content by disgarding damaged rect and ignoring
-  // new paint requests. This is a one way operation and there is no way to
-  // reenable painting.
-  void SuppressPaint();
-
-  // Sets the |value| of the given window |property|. Setting to the default
-  // value (e.g., NULL) removes the property. The caller is responsible for the
-  // lifetime of any object set as a property on the Window.
-  template<typename T>
-  void SetProperty(const WindowProperty<T>* property, T value);
-
-  // Returns the value of the given window |property|.  Returns the
-  // property-specific default value if the property was not previously set.
-  template<typename T>
-  T GetProperty(const WindowProperty<T>* property) const;
-
-  // Sets the |property| to its default value. Useful for avoiding a cast when
-  // setting to NULL.
-  template<typename T>
-  void ClearProperty(const WindowProperty<T>* property);
-
-  // NativeWidget::[GS]etNativeWindowProperty use strings as keys, and this is
-  // difficult to change while retaining compatibility with other platforms.
-  // TODO(benrg): Find a better solution.
-  void SetNativeWindowProperty(const char* key, void* value);
-  void* GetNativeWindowProperty(const char* key) const;
-
-  // Type of a function to delete a property that this window owns.
-  typedef void (*PropertyDeallocator)(int64 value);
-
-  // Overridden from ui::LayerDelegate:
-  void OnDeviceScaleFactorChanged(float device_scale_factor) override;
-
-#if !defined(NDEBUG)
-  // These methods are useful when debugging.
-  std::string GetDebugInfo() const;
-  void PrintWindowHierarchy(int depth) const;
-#endif
-
-  // Returns true if there was state needing to be cleaned up.
-  bool CleanupGestureState();
-
- 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;
-  friend class LayoutManager;
-  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);
-  int64 GetPropertyInternal(const void* key, int64 default_value) const;
-
-  // Returns true if the mouse pointer at relative-to-this-Window's-origin
-  // |local_point| can trigger an event for this Window.
-  // TODO(beng): A Window can supply a hit-test mask to cause some portions of
-  // itself to not trigger events, causing the events to fall through to the
-  // Window behind.
-  bool HitTest(const gfx::Point& local_point);
-
-  // Changes the bounds of the window without condition.
-  void SetBoundsInternal(const gfx::Rect& new_bounds);
-
-  // Updates the visible state of the layer, but does not make visible-state
-  // specific changes. Called from Show()/Hide().
-  void SetVisible(bool visible);
-
-  // Schedules a paint for the Window's entire bounds.
-  void SchedulePaint();
-
-  // Asks the delegate to paint the window and invokes PaintLayerlessChildren()
-  // to paint any children with no layers.
-  void Paint(gfx::Canvas* canvas);
-
-  // Paints any layerless children to |canvas|.
-  void PaintLayerlessChildren(gfx::Canvas* canvas);
-
-  // Gets a Window (either this one or a subwindow) containing |local_point|.
-  // If |return_tightest| is true, returns the tightest-containing (i.e.
-  // furthest down the hierarchy) Window containing the point; otherwise,
-  // returns the loosest.  If |for_event_handling| is true, then hit-test masks
-  // are honored; otherwise, only bounds checks are performed.
-  Window* GetWindowForPoint(const gfx::Point& local_point,
-                            bool return_tightest,
-                            bool for_event_handling);
-
-  // Implementation of RemoveChild(). If |child| is being removed as the result
-  // of an add, |new_parent| is the new parent |child| is going to be parented
-  // to.
-  void RemoveChildImpl(Window* child, Window* new_parent);
-
-  // If this Window has a layer the layer's parent is set to NULL, otherwise
-  // UnparentLayers() is invoked on all the children. |offset| is the offset
-  // relative to the nearest ancestor with a layer.
-  void UnparentLayers(bool has_layerless_ancestor,
-                      const gfx::Vector2d& offset);
-
-  // If this Window has a layer it is added to |parent| and the origin set to
-  // |offset|. Otherwise this recurses through the children invoking
-  // ReparentLayers(). The net effect is both setting the parent of layers to
-  // |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();
-
-  // The various stacking functions call into this to do the actual stacking.
-  void StackChildRelativeTo(Window* child,
-                            Window* target,
-                            StackDirection direction);
-
-  // 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.
-  void NotifyRemovingFromRootWindow(Window* new_root);
-  void NotifyAddedToRootWindow();
-
-  // Methods implementing hierarchy change notifications. See WindowObserver for
-  // more details.
-  void NotifyWindowHierarchyChange(
-      const WindowObserver::HierarchyChangeParams& params);
-  // Notifies this window and its child hierarchy.
-  void NotifyWindowHierarchyChangeDown(
-      const WindowObserver::HierarchyChangeParams& params);
-  // Notifies this window and its parent hierarchy.
-  void NotifyWindowHierarchyChangeUp(
-      const WindowObserver::HierarchyChangeParams& params);
-  // Notifies this window's observers.
-  void NotifyWindowHierarchyChangeAtReceiver(
-      const WindowObserver::HierarchyChangeParams& params);
-
-  // Methods implementing visibility change notifications. See WindowObserver
-  // for more details.
-  void NotifyWindowVisibilityChanged(aura::Window* target, bool visible);
-  // Notifies this window's observers. Returns false if |this| was deleted
-  // during the call (by an observer), otherwise true.
-  bool NotifyWindowVisibilityChangedAtReceiver(aura::Window* target,
-                                               bool visible);
-  // Notifies this window and its child hierarchy. Returns false if
-  // |this| was deleted during the call (by an observer), otherwise
-  // true.
-  bool NotifyWindowVisibilityChangedDown(aura::Window* target, bool visible);
-  // Notifies this window and its parent hierarchy.
-  void NotifyWindowVisibilityChangedUp(aura::Window* target, bool visible);
-
-  // Notifies this window and its child hierarchy of a transform applied to
-  // |source|.
-  void NotifyAncestorWindowTransformed(Window* source);
-
-  // Invoked when the bounds of the window changes. This may be invoked directly
-  // by us, or from the closure returned by PrepareForLayerBoundsChange() after
-  // the bounds of the layer has changed. |old_bounds| is the previous bounds.
-  void OnWindowBoundsChanged(const gfx::Rect& old_bounds);
-
-  // Overridden from ui::LayerDelegate:
-  void OnPaintLayer(gfx::Canvas* canvas) override;
-  void OnDelegatedFrameDamage(const gfx::Rect& damage_rect_in_dip) override;
-  base::Closure PrepareForLayerBoundsChange() override;
-
-  // Overridden from ui::EventTarget:
-  bool CanAcceptEvent(const ui::Event& event) override;
-  EventTarget* GetParentTarget() override;
-  scoped_ptr<ui::EventTargetIterator> GetChildIterator() override;
-  ui::EventTargeter* GetEventTargeter() override;
-  void ConvertEventToTarget(ui::EventTarget* target,
-                            ui::LocatedEvent* event) override;
-
-  // Updates the layer name based on the window's name and id.
-  void UpdateLayerName();
-
-  // Returns true if the mouse is currently within our bounds.
-  bool ContainsMouse();
-
-  // Returns the first ancestor (starting at |this|) with a layer. |offset| is
-  // set to the offset from |this| to the first ancestor with a layer. |offset|
-  // may be NULL.
-  Window* GetAncestorWithLayer(gfx::Vector2d* offset) {
-    return const_cast<Window*>(
-        const_cast<const Window*>(this)->GetAncestorWithLayer(offset));
-  }
-  const Window* GetAncestorWithLayer(gfx::Vector2d* offset) const;
-
-  // Bounds of this window relative to the parent. This is cached as the bounds
-  // of the Layer and Window are not necessarily the same. In particular bounds
-  // of the Layer are relative to the first ancestor with a Layer, where as this
-  // is relative to the parent Window.
-  gfx::Rect bounds_;
-
-  WindowTreeHost* host_;
-
-  ui::wm::WindowType type_;
-
-  // True if the Window is owned by its parent - i.e. it will be deleted by its
-  // parent during its parents destruction. True is the default.
-  bool owned_by_parent_;
-
-  WindowDelegate* delegate_;
-
-  // The Window's parent.
-  Window* parent_;
-
-  // Child windows. Topmost is last.
-  Windows children_;
-
-  // 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_;
-
-  // Whether layer is initialized as non-opaque.
-  bool transparent_;
-
-  scoped_ptr<LayoutManager> layout_manager_;
-  scoped_ptr<ui::EventTargeter> targeter_;
-
-  void* user_data_;
-
-  // Makes the window pass all events through to any windows behind it.
-  bool ignore_events_;
-
-  // See set_hit_test_bounds_override_inner().
-  gfx::Insets hit_test_bounds_override_inner_;
-
-  ObserverList<WindowObserver, true> observers_;
-
-  // Value struct to keep the name and deallocator for this property.
-  // Key cannot be used for this purpose because it can be char* or
-  // WindowProperty<>.
-  struct Value {
-    const char* name;
-    int64 value;
-    PropertyDeallocator deallocator;
-  };
-
-  std::map<const void*, Value> prop_map_;
-
-  DISALLOW_COPY_AND_ASSIGN(Window);
-};
-
-}  // namespace aura
-
-#endif  // UI_AURA_WINDOW_H_