Initial cut at layerless windows.

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"
@@ skipping 17 matching lines @@
 #include "ui/aura/window_tree_host.h"
 #include "ui/compositor/compositor.h"
 #include "ui/compositor/layer.h"
 #include "ui/gfx/animation/multi_animation.h"
 #include "ui/gfx/canvas.h"
 #include "ui/gfx/path.h"
 #include "ui/gfx/screen.h"
 
 namespace aura {
 
+namespace {
+
+WindowLayerType UILayerTypeToWindowLayerType(ui::LayerType layer_type) {
+  switch (layer_type) {
+    case ui::LAYER_NOT_DRAWN:
+      return WINDOW_LAYER_NOT_DRAWN;
+    case ui::LAYER_TEXTURED:
+      return WINDOW_LAYER_TEXTURED;
+    case ui::LAYER_SOLID_COLOR:
+      return WINDOW_LAYER_SOLID_COLOR;
+  }
+  NOTREACHED();
+  return WINDOW_LAYER_NOT_DRAWN;
+}
+
+ui::LayerType WindowLayerTypeToUILayerType(WindowLayerType window_layer_type) {
+  switch (window_layer_type) {
+    case WINDOW_LAYER_NONE:
+      break;
+    case WINDOW_LAYER_NOT_DRAWN:
+      return ui::LAYER_NOT_DRAWN;
+    case WINDOW_LAYER_TEXTURED:
+      return ui::LAYER_TEXTURED;
+    case WINDOW_LAYER_SOLID_COLOR:
+      return ui::LAYER_SOLID_COLOR;
+  }
+  NOTREACHED();
+  return ui::LAYER_NOT_DRAWN;
+}
+
+}  // namespace
+
 class ScopedCursorHider {
  public:
   explicit ScopedCursorHider(Window* window)
       : window_(window),
         hid_cursor_(false) {
     if (!window_->HasDispatcher())
       return;
     const bool cursor_is_in_bounds = window_->GetBoundsInScreen().Contains(
         Env::GetInstance()->last_mouse_location());
     client::CursorClient* cursor_client = client::GetCursorClient(window_);
@@ skipping 22 matching lines @@
   }
 
  private:
   Window* window_;
   bool hid_cursor_;
 
   DISALLOW_COPY_AND_ASSIGN(ScopedCursorHider);
 };
 
 Window::Window(WindowDelegate* delegate)
-    : dispatcher_(NULL),
+    : window_layer_type_(WINDOW_LAYER_NOT_DRAWN),
+      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),
@@ skipping 56 matching lines @@
 
   // If we have layer it will either be destroyed by layer_owner_'s dtor, or by
   // whoever acquired it. We don't have a layer if Init() wasn't invoked, which
   // can happen in tests.
   if (layer_)
     layer_->set_delegate(NULL);
   layer_ = NULL;
 }
 
 void Window::Init(ui::LayerType layer_type) {
-  layer_ = new ui::Layer(layer_type);
-  layer_owner_.reset(layer_);
-  layer_->SetVisible(false);
-  layer_->set_delegate(this);
-  UpdateLayerName(name_);
-  layer_->SetFillsBoundsOpaquely(!transparent_);
+  InitWithWindowLayerType(UILayerTypeToWindowLayerType(layer_type));
+}
+
+void Window::InitWithWindowLayerType(WindowLayerType window_layer_type) {
+  window_layer_type_ = window_layer_type;
+
+  if (window_layer_type != WINDOW_LAYER_NONE) {
+    layer_ = new ui::Layer(WindowLayerTypeToUILayerType(window_layer_type));
+    layer_owner_.reset(layer_);
+    layer_->SetVisible(false);
+    layer_->set_delegate(this);
+    UpdateLayerName(name_);
+    layer_->SetFillsBoundsOpaquely(!transparent_);
+  }
 
   Env::GetInstance()->NotifyWindowInitialized(this);
 }
 
 ui::Layer* Window::RecreateLayer() {
   // Disconnect the old layer, but don't delete it.
   ui::Layer* old_layer = AcquireLayer();
   if (!old_layer)
     return NULL;
 
@@ skipping 23 matching lines @@
        it != children_copy.end();
        ++it) {
     ui::Layer* child = *it;
     layer_->Add(child);
   }
   return old_layer;
 }
 
 void Window::SetType(client::WindowType type) {
   // Cannot change type after the window is initialized.
-  DCHECK(!layer());
+  DCHECK(!layer_);
   type_ = type;
 }
 
 void Window::SetName(const std::string& name) {
   name_ = name;
 
-  if (layer())
+  if (layer_)
     UpdateLayerName(name_);
 }
 
 void Window::SetTransparent(bool transparent) {
   transparent_ = transparent;
-  if (layer())
+  if (layer_)
     layer_->SetFillsBoundsOpaquely(!transparent_);
 }
 
 Window* Window::GetRootWindow() {
   return const_cast<Window*>(
       static_cast<const Window*>(this)->GetRootWindow());
 }
 
 const Window* Window::GetRootWindow() const {
   return dispatcher_ ? this : parent_ ? parent_->GetRootWindow() : NULL;
@@ skipping 20 matching lines @@
   }
   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).
-  return visible_ && layer_ && layer_->IsDrawn();
+  for (const Window* window = this; window; window = window->parent()) {
+    if (!window->visible_)
+      return false;
+    if (window->layer_)
+      return window->layer_->IsDrawn();
+  }
+  return false;
 }
 
 gfx::Rect Window::GetBoundsInRootWindow() const {
   // TODO(beng): There may be a better way to handle this, and the existing code
   //             is likely wrong anyway in a multi-display world, but this will
   //             do for now.
   if (!GetRootWindow())
     return bounds();
   gfx::Point origin = bounds().origin();
   ConvertPointToTarget(parent_, GetRootWindow(), &origin);
   return gfx::Rect(origin, bounds().size());
 }
 
 gfx::Rect Window::GetBoundsInScreen() const {
   gfx::Rect bounds(GetBoundsInRootWindow());
   const Window* root = GetRootWindow();
   if (root) {
     aura::client::ScreenPositionClient* screen_position_client =
         aura::client::GetScreenPositionClient(root);
     if (screen_position_client) {
       gfx::Point origin = bounds.origin();
       screen_position_client->ConvertPointToScreen(root, &origin);
       bounds.set_origin(origin);
     }
   }
   return bounds;
 }
 
 void Window::SetTransform(const gfx::Transform& transform) {
+  if (is_layerless()) {
+    // Transforms aren't supported on layerless windows.
+    NOTREACHED();
+    return;
+  }
   WindowEventDispatcher* dispatcher = GetDispatcher();
   bool contained_mouse = IsVisible() && dispatcher &&
       ContainsPointInRoot(dispatcher->GetLastMouseLocationInRoot());
-  layer()->SetTransform(transform);
+  layer_->SetTransform(transform);
   if (dispatcher)
     dispatcher->OnWindowTransformed(this, contained_mouse);
 }
 
 void Window::SetLayoutManager(LayoutManager* layout_manager) {
   if (layout_manager == layout_manager_)
     return;
   layout_manager_.reset(layout_manager);
   if (!layout_manager)
     return;
@@ skipping 19 matching lines @@
     gfx::Point origin = new_bounds_in_screen.origin();
     aura::client::ScreenPositionClient* screen_position_client =
         aura::client::GetScreenPositionClient(root);
     screen_position_client->SetBounds(this, new_bounds_in_screen, dst_display);
     return;
   }
   SetBounds(new_bounds_in_screen);
 }
 
 gfx::Rect Window::GetTargetBounds() const {
-  return layer_->GetTargetBounds();
-}
-
-const gfx::Rect& Window::bounds() const {
-  return layer_->bounds();
+  // TODO(sky): this needs to be updated when there is a layerless ancestor.
+  return is_layerless() ? bounds() : layer_->GetTargetBounds();
 }
 
 void Window::SchedulePaintInRect(const gfx::Rect& rect) {
-  if (layer_->SchedulePaint(rect)) {
+  if (is_layerless() && parent_) {
+    // Notification of paint scheduled happens for the window with a layer.
+    gfx::Rect parent_rect(bounds().size());
+    parent_rect.Intersect(rect);
+    if (!parent_rect.IsEmpty()) {
+      parent_rect.Offset(bounds().origin().OffsetFromOrigin());
+      parent_->SchedulePaintInRect(parent_rect);
+    }
+  } else if (layer_ && layer_->SchedulePaint(rect)) {
     FOR_EACH_OBSERVER(
         WindowObserver, observers_, OnWindowPaintScheduled(this, rect));
   }
 }
 
 void Window::StackChildAtTop(Window* child) {
   if (children_.size() <= 1 || child == children_.back())
     return;  // In the front already.
   StackChildAbove(child, children_.back());
 }
@@ skipping 19 matching lines @@
   params.old_parent = child->parent();
   params.phase = WindowObserver::HierarchyChangeParams::HIERARCHY_CHANGING;
   NotifyWindowHierarchyChange(params);
 
   Window* old_root = child->GetRootWindow();
 
   DCHECK(std::find(children_.begin(), children_.end(), child) ==
       children_.end());
   if (child->parent())
     child->parent()->RemoveChildImpl(child, this);
+
+  gfx::Vector2d offset;
+  aura::Window* ancestor_with_layer = GetAncestorWithLayer(&offset);
+  if (ancestor_with_layer) {
+    offset += child->bounds().OffsetFromOrigin();
+    child->ReparentLayers(ancestor_with_layer->layer(), offset);
+  }
+
   child->parent_ = this;
 
-  layer_->Add(child->layer_);
-
   children_.push_back(child);
   if (layout_manager_)
     layout_manager_->OnWindowAddedToLayout(child);
   FOR_EACH_OBSERVER(WindowObserver, observers_, OnWindowAdded(child));
   child->OnParentChanged();
 
   Window* root_window = GetRootWindow();
   if (root_window && old_root != root_window) {
     root_window->GetDispatcher()->OnWindowAddedToRootWindow(child);
     child->NotifyAddedToRootWindow();
@@ skipping 71 matching lines @@
     return;
   if (source->GetRootWindow() != target->GetRootWindow()) {
     client::ScreenPositionClient* source_client =
         client::GetScreenPositionClient(source->GetRootWindow());
     source_client->ConvertPointToScreen(source, point);
 
     client::ScreenPositionClient* target_client =
         client::GetScreenPositionClient(target->GetRootWindow());
     target_client->ConvertPointFromScreen(target, point);
   } else {
-    ui::Layer::ConvertPointToLayer(source->layer(), target->layer(), point);
+    ui::Layer::ConvertPointToLayer(source->layer_, target->layer_, point);
   }
 }
 
 void Window::MoveCursorTo(const gfx::Point& point_in_window) {
   Window* root_window = GetRootWindow();
   DCHECK(root_window);
   gfx::Point point_in_root(point_in_window);
   ConvertPointToTarget(this, root_window, &point_in_root);
   root_window->GetDispatcher()->MoveCursorTo(point_in_root);
 }
@@ skipping 249 matching lines @@
     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()));
   }
 
   gfx::Rect old_bounds = GetTargetBounds();
 
   // Always need to set the layer's bounds -- even if it is to the same thing.
   // This may cause important side effects such as stopping animation.
-  layer_->SetBounds(actual_new_bounds);
+  if (is_layerless()) {
+    const gfx::Vector2d origin_delta = new_bounds.OffsetFromOrigin() -
+        bounds_.OffsetFromOrigin();
+    bounds_ = new_bounds;
+    OffsetLayerBounds(origin_delta);
+  } else {
+    if (parent_ && parent_->is_layerless()) {
+      gfx::Vector2d offset;
+      const aura::Window* ancestor_with_layer =
+          parent_->GetAncestorWithLayer(&offset);
+      if (ancestor_with_layer)
+        actual_new_bounds.Offset(offset);
+    }
+    layer_->SetBounds(actual_new_bounds);
+  }
 
   // If we are currently not the layer's delegate, we will not get bounds
   // changed notification from the layer (this typically happens after animating
   // hidden). We must notify ourselves.
-  if (layer_->delegate() != this)
-    OnLayerBoundsChanged(old_bounds, ContainsMouse());
+  if (is_layerless() || layer_->delegate() != this)
+    OnWindowBoundsChanged(old_bounds, ContainsMouse());
 }
 
 void Window::SetVisible(bool visible) {
   if (visible == layer_->GetTargetVisibility())
     return;  // No change.
 
   FOR_EACH_OBSERVER(WindowObserver, observers_,
                     OnWindowVisibilityChanging(this, visible));
 
   WindowEventDispatcher* dispatcher = GetDispatcher();
@@ skipping 84 matching lines @@
   if (layout_manager_)
     layout_manager_->OnWillRemoveWindowFromLayout(child);
   FOR_EACH_OBSERVER(WindowObserver, observers_, OnWillRemoveWindow(child));
   Window* root_window = child->GetRootWindow();
   Window* new_root_window = new_parent ? new_parent->GetRootWindow() : NULL;
   if (root_window && root_window != new_root_window) {
     root_window->GetDispatcher()->OnWindowRemovedFromRootWindow(
         child, new_root_window);
     child->NotifyRemovingFromRootWindow();
   }
+
+  gfx::Vector2d offset;
+  GetAncestorWithLayer(&offset);
+  child->UnparentLayers(is_layerless(), offset);
   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_)
-    layer_->Remove(child->layer_);
   Windows::iterator i = std::find(children_.begin(), children_.end(), child);
   DCHECK(i != children_.end());
   children_.erase(i);
   child->OnParentChanged();
   if (layout_manager_)
     layout_manager_->OnWindowRemovedFromLayout(child);
 }
 
+void Window::UnparentLayers(bool has_layerless_ancestor,
+                            const gfx::Vector2d& offset) {
+  if (is_layerless()) {
+    const gfx::Vector2d new_offset = offset + bounds().OffsetFromOrigin();
+    for (size_t i = 0; i < children_.size(); ++i) {
+      children_[i]->UnparentLayers(true, new_offset);
+    }
+  } else {
+    // We should only remove the child's layer if the child still owns that

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

use of the term "child" here is confusing.

// We should only remove this window's layer from its parent if this window
still owns the layer.

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

Ya, sorry, I copied this comment from 858 old where it was in terms of child.
Updated.

+    // 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 (layer_owner_) {
+      if (layer_->parent())
+        layer_->parent()->Remove(layer_);
+      if (has_layerless_ancestor) {
+        const gfx::Rect real_bounds(bounds_);
+        gfx::Rect layer_bounds(layer_->bounds());
+        layer_bounds.Offset(-offset);
+        layer_->SetBounds(layer_bounds);
+        bounds_ = real_bounds;
+      }
+    }
+  }
+}
+
+void Window::ReparentLayers(ui::Layer* parent_layer,
+                            const gfx::Vector2d& offset) {
+  if (is_layerless()) {
+    for (size_t i = 0; i < children_.size(); ++i) {
+      children_[i]->ReparentLayers(
+          parent_layer,
+          offset + children_[i]->bounds().OffsetFromOrigin());
+    }
+  } else {
+    const gfx::Rect real_bounds(bounds());
+    parent_layer->Add(layer_);
+    gfx::Rect layer_bounds(layer_->bounds().size());
+    layer_bounds += offset;
+    layer_->SetBounds(layer_bounds);
+    bounds_ = real_bounds;
+  }
+}
+
+void Window::OffsetLayerBounds(const gfx::Vector2d& offset) {
+  if (is_layerless()) {
+    for (size_t i = 0; i < children_.size(); ++i)
+      children_[i]->OffsetLayerBounds(offset);
+  } else {
+    gfx::Rect layer_bounds(layer_->bounds());
+    layer_bounds += offset;
+    layer_->SetBounds(layer_bounds);
+  }
+}
+
 void Window::OnParentChanged() {
   FOR_EACH_OBSERVER(
       WindowObserver, observers_, OnWindowParentChanged(this, parent_));
 }
 
 bool Window::GetAllTransientAncestors(Window* window,
                                       Windows* ancestors) const {
   for (; window; window = window->transient_parent()) {
     if (window->parent() == this)
       ancestors->push_back(window);
@@ skipping 58 matching lines @@
       ++final_target_i;
     }
   }
 
   // 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 (final_target_i > 0 &&
          children_[direction == STACK_ABOVE ? final_target_i :
-                                              final_target_i - 1]->layer()
+                                              final_target_i - 1]->layer_
              ->delegate() == NULL) {
     --final_target_i;
   }
 
   Window* final_target = children_[final_target_i];
 
   // If we couldn't find a valid target position, don't move anything.
-  if (direction == STACK_ABOVE && final_target->layer()->delegate() == NULL)
+  if (direction == STACK_ABOVE && final_target->layer_->delegate() == NULL)
     return;
 
   // Don't try to stack a child above itself.
   if (child == final_target)
     return;
 
   // Move the child.
   StackChildRelativeToImpl(child, final_target, direction);
 
   // Stack any transient children that share the same parent to be in front of
@@ skipping 31 matching lines @@
     return;
 
   const size_t dest_i =
       direction == STACK_ABOVE ?
       (child_i < target_i ? target_i : target_i + 1) :
       (child_i < target_i ? target_i - 1 : target_i);
   children_.erase(children_.begin() + child_i);
   children_.insert(children_.begin() + dest_i, child);
 
   if (direction == STACK_ABOVE)
-    layer()->StackAbove(child->layer(), target->layer());
+    layer_->StackAbove(child->layer_, target->layer_);
   else
-    layer()->StackBelow(child->layer(), target->layer());
+    layer_->StackBelow(child->layer_, target->layer_);
 
   child->OnStackingChanged();
 }
 
 void Window::OnStackingChanged() {
   FOR_EACH_OBSERVER(WindowObserver, observers_, OnWindowStackingChanged(this));
 }
 
 void Window::NotifyRemovingFromRootWindow() {
   FOR_EACH_OBSERVER(WindowObserver, observers_,
@@ skipping 110 matching lines @@
 }
 
 void Window::NotifyWindowVisibilityChangedUp(aura::Window* target,
                                              bool visible) {
   for (Window* window = this; window; window = window->parent()) {
     bool ret = window->NotifyWindowVisibilityChangedAtReceiver(target, visible);
     DCHECK(ret);
   }
 }
 
-void Window::OnLayerBoundsChanged(const gfx::Rect& old_bounds,
-                                  bool contained_mouse) {
+void Window::OnWindowBoundsChanged(const gfx::Rect& old_bounds,
+                                   bool contained_mouse) {
+  if (layer_) {
+    bounds_ = layer_->bounds();
+    if (parent_ && parent_->is_layerless()) {
+      gfx::Vector2d offset;
+      aura::Window* ancestor_with_layer =
+          parent_->GetAncestorWithLayer(&offset);
+      if (ancestor_with_layer)
+        bounds_.Offset(-offset);
+    }
+  }
+
   if (layout_manager_)
     layout_manager_->OnWindowResized();
   if (delegate_)
     delegate_->OnBoundsChanged(old_bounds, bounds());
   FOR_EACH_OBSERVER(WindowObserver,
                     observers_,
                     OnWindowBoundsChanged(this, old_bounds, bounds()));
   WindowEventDispatcher* dispatcher = GetDispatcher();
   if (dispatcher)
     dispatcher->OnWindowBoundsChanged(this, contained_mouse);
 }
 
 void Window::OnPaintLayer(gfx::Canvas* canvas) {
   if (delegate_)
     delegate_->OnPaint(canvas);
 }
 
 base::Closure Window::PrepareForLayerBoundsChange() {
-  return base::Bind(&Window::OnLayerBoundsChanged, base::Unretained(this),
+  return base::Bind(&Window::OnWindowBoundsChanged, base::Unretained(this),
                     bounds(), ContainsMouse());
 }
 
 bool Window::CanAcceptEvent(const ui::Event& event) {
   if (!IsVisible())
     return false;
 
   // The client may forbid certain windows from receiving events at a given
   // point in time.
   client::EventClient* client = client::GetEventClient(GetRootWindow());
@@ skipping 14 matching lines @@
   if (dispatcher_) {
     return client::GetEventClient(this) ?
         client::GetEventClient(this)->GetToplevelEventTarget() :
             Env::GetInstance();
   }
   return parent_;
 }
 
 void Window::UpdateLayerName(const std::string& name) {
 #if !defined(NDEBUG)
-  DCHECK(layer());
+  DCHECK(layer_);
 
   std::string layer_name(name_);
   if (layer_name.empty())
     layer_name.append("Unnamed Window");
 
   if (id_ != -1) {
     char id_buf[10];
     base::snprintf(id_buf, sizeof(id_buf), " %d", id_);
     layer_name.append(id_buf);
   }
-  layer()->set_name(layer_name);
+  layer_->set_name(layer_name);
 #endif
 }
 
 bool Window::ContainsMouse() {
   bool contains_mouse = false;
   if (IsVisible()) {
     WindowEventDispatcher* dispatcher = GetDispatcher();
     contains_mouse = dispatcher &&
         ContainsPointInRoot(dispatcher->GetLastMouseLocationInRoot());
   }
   return contains_mouse;
 }
 
+const Window* Window::GetAncestorWithLayer(gfx::Vector2d* offset) const {
+  for (const aura::Window* window = this; window; window = window->parent()) {
+    if (!window->is_layerless())
+      return window;
+    *offset += window->bounds().OffsetFromOrigin();
+  }
+  *offset = gfx::Vector2d();
+  return NULL;
+}
+
 }  // namespace aura