MacViews: Fix child window z-order and SetBounds

ui/views/test/widget_test_aura.cc

Index: ui/views/test/widget_test_aura.cc
diff --git a/ui/views/test/widget_test_aura.cc b/ui/views/test/widget_test_aura.cc
index 1b2dd139fc10fc2c06caee0c9f3b0847fcfd0462..e73c8c74cacfb2f77d414ca5e07db2079b1f9b68 100644
--- a/ui/views/test/widget_test_aura.cc
+++ b/ui/views/test/widget_test_aura.cc
@@ -11,6 +11,37 @@
 namespace views {
 namespace test {
 
+namespace {
+
+// Perform a pre-order traversal of |children| and all descendants, looking for
+// |first| and |second|. If |first| is found before |second|, return true.
+// When a layer is found, it is set to null. Returns once |second| is found, or
+// when there are no children left.
+// Note than ui::Layer children are bottom-to-top stacking order.
+bool FindLayersInOrder(const std::vector<ui::Layer*>& children,

[Robert Sesek, 2015/01/07 00:11:40]

This function is not easy to reason about, but I don't really have suggestions.

Would this work instead? Create two arrays of the first's and second's parent
hierarchy up to the root, and then just linearly compare the two. If that's
messier/won't work, this is fine, I just had to stare at it for a while.

[tapted, 2015/01/07 01:44:12]

Yeah - I felt bad putting recursion in a test function :(, but I think it's
warranted. The tricky part with walking up to the root is that each child would
need to know its index in its parent's array of children, since that also
influences stacking. But I think you're right - I could just create two arrays
of these indexes (going up), reverse the arrays, and then do a
std::lexicographical_compare() (handling corner cases like not-sharing a root).
But it's quite a bit more state to maintain over a pre-order traversal.

sky might know a way to get this info from something that exists already, but I
couldn't find anything.

Or maybe ui::Layer (or aura::Window or aura::WindowStackingClient, or even
Widget ..) could benefit from something like [NSApp orderedWindows] that does
the traversal, then have the same algorithm as mac. As it is now, the
`IsStackedAbove` logic is the same idea as mac, just with a recursive `visitor`,
so I think keeping that bit consistent has merit.

+                       const ui::Layer** first,
+                       const ui::Layer** second) {
+  for (const ui::Layer* child : children) {
+    if (child == *second) {
+      *second = nullptr;
+      return *first == nullptr;
+    }
+
+    if (child == *first)
+      *first = nullptr;
+
+    if (FindLayersInOrder(child->children(), first, second))
+      return true;
+
+    // If second is cleared without success, exit early with failure.
+    if (!*second)
+      return false;
+  }
+  return false;
+}
+
+}  // namespace
+
 // static
 void WidgetTest::SimulateNativeDestroy(Widget* widget) {
   delete widget->GetNativeView();
@@ -22,6 +53,19 @@ bool WidgetTest::IsNativeWindowVisible(gfx::NativeWindow window) {
 }
 
 // static
+bool WidgetTest::IsWindowStackedAbove(Widget* above, Widget* below) {
+  CHECK(above->IsVisible());
+  CHECK(below->IsVisible());
+
+  ui::Layer* root_layer = above->GetNativeWindow()->GetRootWindow()->layer();
+
+  // Traversal is bottom-to-top, so |below| should be found first.
+  const ui::Layer* first = below->GetLayer();
+  const ui::Layer* second = above->GetLayer();
+  return FindLayersInOrder(root_layer->children(), &first, &second);
+}
+
+// static
 ui::EventProcessor* WidgetTest::GetEventProcessor(Widget* widget) {
   return widget->GetNativeWindow()->GetHost()->event_processor();
 }