Reorder the NativeViews attached to a view via kViewHostKey according to the position of the view

ui/views/widget/native_widget_aura.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/views/widget/native_widget_aura.h"
 
 #include "base/bind.h"
 #include "base/string_util.h"
 #include "third_party/skia/include/core/SkRegion.h"
 #include "ui/aura/client/activation_client.h"
@@ skipping 12 matching lines @@
 #include "ui/base/dragdrop/os_exchange_data.h"
 #include "ui/base/events/event.h"
 #include "ui/base/ui_base_types.h"
 #include "ui/compositor/layer.h"
 #include "ui/gfx/canvas.h"
 #include "ui/gfx/font.h"
 #include "ui/gfx/screen.h"
 #include "ui/native_theme/native_theme_aura.h"
 #include "ui/views/drag_utils.h"
 #include "ui/views/ime/input_method_bridge.h"
+#include "ui/views/view_constants_aura.h"
 #include "ui/views/views_delegate.h"
 #include "ui/views/widget/desktop_aura/desktop_native_widget_aura.h"
 #include "ui/views/widget/drop_helper.h"
 #include "ui/views/widget/native_widget_aura_window_observer.h"
 #include "ui/views/widget/native_widget_delegate.h"
 #include "ui/views/widget/root_view.h"
 #include "ui/views/widget/tooltip_manager_aura.h"
 #include "ui/views/widget/widget_aura_utils.h"
 #include "ui/views/widget/widget_delegate.h"
 
 #if defined(OS_WIN)
 #include "base/win/scoped_gdi_object.h"
 #include "base/win/win_util.h"
 #include "ui/base/l10n/l10n_util_win.h"
 #include "ui/views/widget/desktop_aura/desktop_root_window_host_win.h"
 #endif
 
 #if !defined(OS_CHROMEOS)
 #include "ui/views/widget/desktop_aura/desktop_root_window_host.h"
 #endif
 
 namespace views {
 
 namespace {
 
 void SetRestoreBounds(aura::Window* window, const gfx::Rect& bounds) {
   window->SetProperty(aura::client::kRestoreBoundsKey, new gfx::Rect(bounds));
 }
 
+// Sets |order| to the list of views whose layer / attached window's layer
+// is a child of |parent_layer|. |order| is sorted in ascending z-order of
+// the views.
+// |hosts| are the views with an attached window whose layer is a child of
+// |parent_layer|. For the sake of simplificity |hosts| must all have id
+// |host_id|.
+void GetOrderOfViewsWithLayers(
+    views::View* current_view,
+    ui::Layer* parent_layer,
+    int host_id,
+    const std::map<views::View*, aura::Window*>& hosts,
+    std::vector<views::View*>* order) {
+  DCHECK(current_view);
+  DCHECK(parent_layer);
+  DCHECK(order);
+  if (current_view->layer() &&
+      current_view->layer()->parent() == parent_layer) {
+    order->push_back(current_view);
+    // |hosts| may contain a child of |current_view|.
+  } else if (current_view->id() == host_id &&
+             hosts.find(current_view) != hosts.end()) {
+    order->push_back(current_view);
+    return;
+  }
+
+  for (int i = 0; i < current_view->child_count(); ++i) {
+    GetOrderOfViewsWithLayers(current_view->child_at(i), parent_layer,
+        host_id, hosts, order);
+  }
+}
+
 }  // namespace
 
 ////////////////////////////////////////////////////////////////////////////////
 // NativeWidgetAura, public:
 
 NativeWidgetAura::NativeWidgetAura(internal::NativeWidgetDelegate* delegate)
     : delegate_(delegate),
       window_(new aura::Window(this)),
       ownership_(Widget::InitParams::NATIVE_WIDGET_OWNS_WIDGET),
       close_widget_factory_(this),
@@ skipping 952 matching lines @@
   }
 
   // And now, notify them that they have a brand new parent.
   for (Widget::Widgets::iterator it = widgets.begin();
       it != widgets.end(); ++it) {
     (*it)->NotifyNativeViewHierarchyChanged(true, new_parent);
   }
 }
 
 // static
+// TODO(pkotwicz): The implementation of the NativeWidgetPrivate statics is the
+// same for NativeWidgetAura and DesktopNativeWidgetAura. Move the
+// implementation of the static functions to a different file.
+void NativeWidgetPrivate::ReorderLayers(gfx::NativeView parent,

[sky, 2013/05/21 23:43:55]

I think all this code should be moved into a standalone object. Additionally
this object should implement a WindowObserver so it can automatically update
things when a window is added/removed as well as having a method to explicitly
update order NativeViewHost position in view hieararchy changes.

+                                        View* root_view) {
+  // Reorder the layers according to the positions of the views with layers and
+  // views with attached windows in the view tree. The reordered layers are
+  // positioned above layers for windows which are not attached to a host view.
+  // The reordered layers are however positioned below any window layers with a
+  // NULL delegate.
+
+  // Find all the child windows which are attached to a view.
+  std::map<View*, aura::Window*> hosted_windows;

[sky, 2013/05/21 23:43:55]

This method is long, break it up where you can. For example,
GetViewsWithAssociatedWindow or something would be nice for this part of the
code.

[pkotwicz, 2013/05/23 02:28:07]

Done.

+  const std::vector<aura::Window*>& child_windows = parent->children();
+  for (size_t i = 0; i < child_windows.size(); ++i) {
+    aura::Window* child = child_windows[i];
+    View* host_view = child->GetProperty(kHostViewKey);
+    if (host_view) {
+      if (!child->layer()->delegate()) {
+        // If there is a case where the attached NativeView has a NULL layer
+        // delegate, we would need handle this case in View::ReorderChildView().
+        NOTREACHED();
+      }
+
+      hosted_windows[host_view] = child;
+    }
+  }
+

[sky, 2013/05/21 23:43:55]

Can't you early out if hosted_windows is empty?

[pkotwicz, 2013/05/23 02:28:07]

We cannot early out here because there may be views with layers (and we need to
reorder those). Furthermore, we cannot simply call View::ReorderChildLayers()
because we need to stack the view layers below the layers for any windows with a
NULL layer delegate.

[sky, 2013/05/23 15:36:49]

Why don't we change ReorderLayers/ReorderChildLayers to iterate backwards and
stack at bottom. This should take care of this case and simplify things, right?

[pkotwicz, 2013/05/23 17:21:45]

The change you are suggesting would result in changing the default z-order of
calling RecreateLayer().
The new z-order would put the old layer at the top and the view/window with the
new layer at the bottom.
I don't think that changing the default z-order as a result of RecraeteLayer()
is a big but wanted to pass it by you.

[sky, 2013/05/23 17:33:35]

I think that better matches expectations, right? RecreateLayer is typically used
for animations where you want the old layer to stay at the top. You'll have to
verify that though.

+  // Compute the desired z-order of the layers based on the order of the views
+  // with layers and views with attached windows in the view tree.
+  std::vector<View*> view_with_layer_order;
+  {
+    // Temporarily modify the ids of the views attached to a window to simplify

[sky, 2013/05/21 23:43:55]

Yuck! Don't muck with the ids like this.

[pkotwicz, 2013/05/23 02:28:07]

No more modifying of the ids

+    // GetOrderOfViewsWithLayers.
+    const int kHostViewId = 1;
+    std::map<View*, int> old_ids;
+    for (std::map<View*, aura::Window*>::iterator it = hosted_windows.begin();
+         it != hosted_windows.end(); ++it) {
+      View* v = it->first;
+      old_ids[v] = v->id();
+      v->set_id(kHostViewId);
+    }
+
+    GetOrderOfViewsWithLayers(root_view, parent->layer(), kHostViewId,
+        hosted_windows, &view_with_layer_order);
+
+    // Reset the view ids.
+    for (std::map<View*, int>::iterator it = old_ids.begin();
+         it != old_ids.end(); ++it) {
+      it->first->set_id(it->second);
+    }
+  }
+
+  // Find the bottommost window with a NULL layer delegate below which the
+  // reordered layers should be stacked. |stack_below_window| should be NULL
+  // if the reodered layers should be stacked at the top.
+  aura::Window* stack_below_window = NULL;
+  for (size_t i = 0; i < child_windows.size(); ++i) {
+    aura::Window* child = child_windows[i];
+    if (!child->layer()->delegate()) {
+      stack_below_window = child;
+      break;
+    }
+  }
+
+  // Reorder the layers and windows.
+  for (size_t i = 0; i < view_with_layer_order.size(); ++i) {
+    View* view = view_with_layer_order[i];
+    ui::Layer* layer = view->layer();
+    aura::Window* window = NULL;
+
+    std::map<View*, aura::Window*>::iterator hosted_window_it =
+        hosted_windows.find(view);
+    if (hosted_window_it != hosted_windows.end()) {
+      window = hosted_window_it->second;
+      layer = window->layer();
+    }
+
+    DCHECK(layer);
+    if (stack_below_window) {
+      if (window)
+        parent->StackChildBelow(window, stack_below_window);
+      parent->layer()->StackBelow(layer, stack_below_window->layer());
+    } else {
+      if (window)
+        parent->StackChildAtTop(window);
+      parent->layer()->StackAtTop(layer);
+    }
+  }
+}
+
+// static
 bool NativeWidgetPrivate::IsMouseButtonDown() {
   return aura::Env::GetInstance()->is_mouse_button_down();
 }
 
 // static
 bool NativeWidgetPrivate::IsTouchDown() {
   return aura::Env::GetInstance()->is_touch_down();
 }
 
 }  // namespace internal
 }  // namespace views