Initial cut at layerless windows.

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>
 
 #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/client/window_types.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/compositor/layer_type.h"
 #include "ui/events/event_constants.h"
 #include "ui/events/event_target.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"
 
 namespace gfx {
 class Display;
 class Transform;
+class Vector2d;
 }
 
 namespace ui {
 class EventHandler;
 class Layer;
 class Texture;
 }
 
 namespace aura {
 
@@ skipping 22 matching lines @@
                            public ui::GestureConsumer {
  public:
   typedef std::vector<Window*> Windows;
 
   explicit Window(WindowDelegate* delegate);
   virtual ~Window();
 
   // Initializes the window. This creates the window's layer.
   void Init(ui::LayerType layer_type);
 
+  // TODO(sky): replace other Init() with this once m32 is more baked.
+  void InitWithWindowLayerType(WindowLayerType layer_type);
+
   // Creates a new layer for the window. Erases the layer-owned bounds, so the
   // caller may wish to set new bounds and other state on the window/layer.
   // Returns the old layer, which can be used for animations. Caller owns the
   // memory for the returned layer and must delete it when animation completes.
   // Returns NULL and does not recreate layer if window does not own its layer.
   ui::Layer* RecreateLayer() WARN_UNUSED_RESULT;
 
   void set_owned_by_parent(bool owned_by_parent) {
     owned_by_parent_ = owned_by_parent;
   }
@@ skipping 13 matching lines @@
 
   const base::string16 title() const { return title_; }
   void set_title(const base::string16& title) { title_ = title; }
 
   bool transparent() const { return transparent_; }
   void SetTransparent(bool transparent);
 
   WindowDelegate* delegate() { return delegate_; }
   const WindowDelegate* delegate() const { return delegate_; }
 
-  const gfx::Rect& bounds() const;
+  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.
   virtual Window* GetRootWindow();
   virtual const Window* GetRootWindow() const;
@@ skipping 279 matching lines @@
   // 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();
 
   // Populates |ancestors| with all transient ancestors of |window| that are
   // children of |this|. Returns true if any ancestors were found, false if not.
   bool GetAllTransientAncestors(Window* window, Windows* ancestors) const;
 
   // Replaces two windows |window1| and |window2| with their possible transient
   // ancestors that are still siblings (have a common transient parent).
   // |window1| and |window2| are not modified if such ancestors cannot be found.
@@ skipping 42 matching lines @@
   // 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);
 
-  // Invoked from the closure returned by PrepareForLayerBoundsChange() after
-  // the bounds of the layer has changed. |old_bounds| is the previous bounds of
-  // the layer, and |contained_mouse| is true if the mouse was previously within
-  // the window's bounds.
-  void OnLayerBoundsChanged(const gfx::Rect& old_bounds, bool contained_mouse);
+  // 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,
+  // and |contained_mouse| is true if the mouse was previously within the
+  // window's bounds.
+  void OnWindowBoundsChanged(const gfx::Rect& old_bounds, bool contained_mouse);
 
   // Overridden from ui::LayerDelegate:
   virtual void OnPaintLayer(gfx::Canvas* canvas) OVERRIDE;
   virtual base::Closure PrepareForLayerBoundsChange() OVERRIDE;
 
   // Overridden from ui::EventTarget:
   virtual bool CanAcceptEvent(const ui::Event& event) OVERRIDE;
   virtual EventTarget* GetParentTarget() OVERRIDE;
 
   // Updates the layer name with a name based on the window's name and id.
   void UpdateLayerName(const std::string& name);
 
   // 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.
+  Window* GetAncestorWithLayer(gfx::Vector2d* offset) {
+    return const_cast<Window*>(
+        const_cast<const Window*>(this)->GetAncestorWithLayer(offset));
+  }
+  const Window* GetAncestorWithLayer(gfx::Vector2d* offset) const;
+
+  bool is_layerless() const { return window_layer_type_ == WINDOW_LAYER_NONE; }

[Ben Goodger (Google), 2013/11/22 05:49:24]

Isn't NULL-checking layer() sufficient?

[sky, 2013/11/22 20:20:12]

I was a bit worried about a comment in the destructor (that I'm removing)
mentioning a test doesn't invoke Init, thereby allowing for a NULL layer_. But,
it seems all tests pass, so I nuked window_layer_type_.

+
+  WindowLayerType window_layer_type_;
+
+  // 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_;
+
   WindowEventDispatcher* dispatcher_;
 
   client::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_;
 
@@ skipping 46 matching lines @@
   };
 
   std::map<const void*, Value> prop_map_;
 
   DISALLOW_COPY_AND_ASSIGN(Window);
 };
 
 }  // namespace aura
 
 #endif  // UI_AURA_WINDOW_H_