Moves management of transients out of Window

ui/aura/window_unittest.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 <string>
 #include <utility>
 #include <vector>
 
 #include "base/basictypes.h"
 #include "base/compiler_specific.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/aura/client/capture_client.h"
 #include "ui/aura/client/focus_change_observer.h"
 #include "ui/aura/client/visibility_client.h"
 #include "ui/aura/client/window_tree_client.h"
-#include "ui/aura/layout_manager.h"
 #include "ui/aura/root_window.h"
 #include "ui/aura/root_window_observer.h"
 #include "ui/aura/test/aura_test_base.h"
 #include "ui/aura/test/event_generator.h"
 #include "ui/aura/test/test_window_delegate.h"
 #include "ui/aura/test/test_windows.h"
 #include "ui/aura/test/window_test_api.h"
 #include "ui/aura/window_delegate.h"
 #include "ui/aura/window_observer.h"
 #include "ui/aura/window_property.h"
@@ skipping 1544 matching lines @@
   transform.Translate(size.height(), 0.0);
   transform.Rotate(90.0);
   dispatcher()->host()->SetTransform(transform);
 
   ui::TouchEvent press(
       ui::ET_TOUCH_PRESSED, gfx::Point(size.height() - 10, 10), 0, getTime());
   dispatcher()->AsRootWindowHostDelegate()->OnHostTouchEvent(&press);
   EXPECT_EQ(gfx::Point(10, 10).ToString(), delegate->position().ToString());
 }
 
-// Various assertions for transient children.
-TEST_F(WindowTest, TransientChildren) {
-  scoped_ptr<Window> parent(CreateTestWindowWithId(0, root_window()));
-  scoped_ptr<Window> w1(CreateTestWindowWithId(1, parent.get()));
-  scoped_ptr<Window> w3(CreateTestWindowWithId(3, parent.get()));
-  Window* w2 = CreateTestWindowWithId(2, parent.get());
-  w1->AddTransientChild(w2);  // w2 is now owned by w1.
-  // Stack w1 at the top (end), this should force w2 to be last (on top of w1).
-  parent->StackChildAtTop(w1.get());
-  ASSERT_EQ(3u, parent->children().size());
-  EXPECT_EQ(w2, parent->children().back());
-
-  // Destroy w1, which should also destroy w3 (since it's a transient child).
-  w1.reset();
-  w2 = NULL;
-  ASSERT_EQ(1u, parent->children().size());
-  EXPECT_EQ(w3.get(), parent->children()[0]);
-
-  w1.reset(CreateTestWindowWithId(4, parent.get()));
-  w2 = CreateTestWindowWithId(5, w3.get());
-  w1->AddTransientChild(w2);
-  parent->StackChildAtTop(w3.get());
-  // Stack w1 at the top (end), this shouldn't affect w2 since it has a
-  // different parent.
-  parent->StackChildAtTop(w1.get());
-  ASSERT_EQ(2u, parent->children().size());
-  EXPECT_EQ(w3.get(), parent->children()[0]);
-  EXPECT_EQ(w1.get(), parent->children()[1]);
-
-  // Hiding parent should hide transient children.
-  EXPECT_TRUE(w2->IsVisible());
-  w1->Hide();
-  EXPECT_FALSE(w2->IsVisible());
-}
-
 namespace {
 DEFINE_WINDOW_PROPERTY_KEY(int, kIntKey, -2);
 DEFINE_WINDOW_PROPERTY_KEY(const char*, kStringKey, "squeamish");
 }
 
 TEST_F(WindowTest, Property) {
   scoped_ptr<Window> w(CreateTestWindowWithId(0, root_window()));
 
   static const char native_prop_key[] = "fnord";
 
@@ skipping 418 matching lines @@
             ui::test::ChildLayerNamesAsString(*root_window()->layer()));
   window1->layer()->set_delegate(NULL);
   root_window()->StackChildAtBottom(window3.get());
 
   // Window 3 should have moved to the bottom.
   EXPECT_EQ("3 1 2", ChildWindowIDsAsString(root_window()));
   EXPECT_EQ("3 1 2",
             ui::test::ChildLayerNamesAsString(*root_window()->layer()));
 }
 
-TEST_F(WindowTest, StackWindowsWhoseLayersHaveNoDelegate) {
-  scoped_ptr<Window> window1(CreateTestWindowWithId(1, root_window()));
-  window1->layer()->set_name("1");
-  scoped_ptr<Window> window2(CreateTestWindowWithId(2, root_window()));
-  window2->layer()->set_name("2");
-  scoped_ptr<Window> window3(CreateTestWindowWithId(3, root_window()));
-  window3->layer()->set_name("3");
-
-  // This brings |window1| (and its layer) to the front.
-  root_window()->StackChildAbove(window1.get(), window3.get());
-  EXPECT_EQ("2 3 1", ChildWindowIDsAsString(root_window()));
-  EXPECT_EQ("2 3 1",
-            ui::test::ChildLayerNamesAsString(*root_window()->layer()));
-
-  // Since |window1| does not have a delegate, |window2| should not move in
-  // front of it, nor should its layer.
-  window1->layer()->set_delegate(NULL);
-  root_window()->StackChildAbove(window2.get(), window1.get());
-  EXPECT_EQ("3 2 1", ChildWindowIDsAsString(root_window()));
-  EXPECT_EQ("3 2 1",
-            ui::test::ChildLayerNamesAsString(*root_window()->layer()));
-
-  // It should still be possible to stack |window3| immediately below |window1|.
-  root_window()->StackChildBelow(window3.get(), window1.get());
-  EXPECT_EQ("2 3 1", ChildWindowIDsAsString(root_window()));
-  EXPECT_EQ("2 3 1",
-            ui::test::ChildLayerNamesAsString(*root_window()->layer()));
-
-  // Since neither |window3| nor |window1| have a delegate, |window2| should
-  // not move in front of either.
-  window3->layer()->set_delegate(NULL);
-  root_window()->StackChildBelow(window2.get(), window1.get());
-  EXPECT_EQ("2 3 1", ChildWindowIDsAsString(root_window()));
-  EXPECT_EQ("2 3 1",
-            ui::test::ChildLayerNamesAsString(*root_window()->layer()));
-}
-
-TEST_F(WindowTest, StackTransientsWhoseLayersHaveNoDelegate) {
-  // Create a window with several transients, then a couple windows on top.
-  scoped_ptr<Window> window1(CreateTestWindowWithId(1, root_window()));
-  scoped_ptr<Window> window11(CreateTransientChild(11, window1.get()));
-  scoped_ptr<Window> window12(CreateTransientChild(12, window1.get()));
-  scoped_ptr<Window> window13(CreateTransientChild(13, window1.get()));
-  scoped_ptr<Window> window2(CreateTestWindowWithId(2, root_window()));
-  scoped_ptr<Window> window3(CreateTestWindowWithId(3, root_window()));
-
-  EXPECT_EQ("1 11 12 13 2 3", ChildWindowIDsAsString(root_window()));
-
-  // Remove the delegates of a couple of transients, as if they are closing
-  // and animating out.
-  window11->layer()->set_delegate(NULL);
-  window13->layer()->set_delegate(NULL);
-
-  // Move window1 to the front.  All transients should move with it, and their
-  // order should be preserved.
-  root_window()->StackChildAtTop(window1.get());
-
-  EXPECT_EQ("2 3 1 11 12 13", ChildWindowIDsAsString(root_window()));
-}
-
 class TestVisibilityClient : public client::VisibilityClient {
  public:
   explicit TestVisibilityClient(Window* root_window)
       : ignore_visibility_changes_(false) {
     client::SetVisibilityClient(root_window, this);
   }
   virtual ~TestVisibilityClient() {
   }
 
   void set_ignore_visibility_changes(bool ignore_visibility_changes) {
@@ skipping 117 matching lines @@
   EXPECT_EQ("0 0 0", d1.GetMouseMotionCountsAndReset());
   EXPECT_EQ("0 0 1", d11.GetMouseMotionCountsAndReset());
 
   // Closing windows
   w11.reset();
   RunAllPendingInMessageLoop();
   EXPECT_EQ("0 0 0", d1.GetMouseMotionCountsAndReset());
   EXPECT_EQ("0 0 0", d11.GetMouseMotionCountsAndReset());
 }
 
-class StackingMadrigalLayoutManager : public LayoutManager {
- public:
-  explicit StackingMadrigalLayoutManager(Window* root_window)
-      : root_window_(root_window) {
-    root_window_->SetLayoutManager(this);
-  }
-  virtual ~StackingMadrigalLayoutManager() {
-  }
-
- private:
-  // Overridden from LayoutManager:
-  virtual void OnWindowResized() OVERRIDE {}
-  virtual void OnWindowAddedToLayout(Window* child) OVERRIDE {}
-  virtual void OnWillRemoveWindowFromLayout(Window* child) OVERRIDE {}
-  virtual void OnWindowRemovedFromLayout(Window* child) OVERRIDE {}
-  virtual void OnChildWindowVisibilityChanged(Window* child,
-                                              bool visible) OVERRIDE {
-    Window::Windows::const_iterator it = root_window_->children().begin();
-    Window* last_window = NULL;
-    for (; it != root_window_->children().end(); ++it) {
-      if (*it == child && last_window) {
-        if (!visible)
-          root_window_->StackChildAbove(last_window, *it);
-        else
-          root_window_->StackChildAbove(*it, last_window);
-        break;
-      }
-      last_window = *it;
-    }
-  }
-  virtual void SetChildBounds(Window* child,
-                              const gfx::Rect& requested_bounds) OVERRIDE {
-    SetChildBoundsDirect(child, requested_bounds);
-  }
-
-  Window* root_window_;
-
-  DISALLOW_COPY_AND_ASSIGN(StackingMadrigalLayoutManager);
-};
-
-class StackingMadrigalVisibilityClient : public client::VisibilityClient {
- public:
-  explicit StackingMadrigalVisibilityClient(Window* root_window)
-      : ignored_window_(NULL) {
-    client::SetVisibilityClient(root_window, this);
-  }
-  virtual ~StackingMadrigalVisibilityClient() {
-  }
-
-  void set_ignored_window(Window* ignored_window) {
-    ignored_window_ = ignored_window;
-  }
-
- private:
-  // Overridden from client::VisibilityClient:
-  virtual void UpdateLayerVisibility(Window* window, bool visible) OVERRIDE {
-    if (!visible) {
-      if (window == ignored_window_)
-        window->layer()->set_delegate(NULL);
-      else
-        window->layer()->SetVisible(visible);
-    } else {
-      window->layer()->SetVisible(visible);
-    }
-  }
-
-  Window* ignored_window_;
-
-  DISALLOW_COPY_AND_ASSIGN(StackingMadrigalVisibilityClient);
-};
-
-// This test attempts to reconstruct a circumstance that can happen when the
-// aura client attempts to manipulate the visibility and delegate of a layer
-// independent of window visibility.
-// A use case is where the client attempts to keep a window visible onscreen
-// even after code has called Hide() on the window. The use case for this would
-// be that window hides are animated (e.g. the window fades out). To prevent
-// spurious updating the client code may also clear window's layer's delegate,
-// so that the window cannot attempt to paint or update it further. The window
-// uses the presence of a NULL layer delegate as a signal in stacking to note
-// that the window is being manipulated by such a use case and its stacking
-// should not be adjusted.
-// One issue that can arise when a window opens two transient children, and the
-// first is hidden. Subsequent attempts to activate the transient parent can
-// result in the transient parent being stacked above the second transient
-// child. A fix is made to Window::StackAbove to prevent this, and this test
-// verifies this fix.
-TEST_F(WindowTest, StackingMadrigal) {
-  new StackingMadrigalLayoutManager(root_window());
-  StackingMadrigalVisibilityClient visibility_client(root_window());
-
-  scoped_ptr<Window> window1(CreateTestWindowWithId(1, root_window()));
-  scoped_ptr<Window> window11(CreateTransientChild(11, window1.get()));
-
-  visibility_client.set_ignored_window(window11.get());
-
-  window11->Show();
-  window11->Hide();
-
-  // As a transient, window11 should still be stacked above window1, even when
-  // hidden.
-  EXPECT_TRUE(WindowIsAbove(window11.get(), window1.get()));
-  EXPECT_TRUE(LayerIsAbove(window11.get(), window1.get()));
-
-  // A new transient should still be above window1.  It will appear behind
-  // window11 because we don't stack windows on top of targets with NULL
-  // delegates.
-  scoped_ptr<Window> window12(CreateTransientChild(12, window1.get()));
-  window12->Show();
-
-  EXPECT_TRUE(WindowIsAbove(window12.get(), window1.get()));
-  EXPECT_TRUE(LayerIsAbove(window12.get(), window1.get()));
-
-  // In earlier versions of the StackChildAbove() method, attempting to stack
-  // window1 above window12 at this point would actually restack the layers
-  // resulting in window12's layer being below window1's layer (though the
-  // windows themselves would still be correctly stacked, so events would pass
-  // through.)
-  root_window()->StackChildAbove(window1.get(), window12.get());
-
-  // Both window12 and its layer should be stacked above window1.
-  EXPECT_TRUE(WindowIsAbove(window12.get(), window1.get()));
-  EXPECT_TRUE(LayerIsAbove(window12.get(), window1.get()));
-}
-
-// Test for an issue where attempting to stack a primary window on top of a
-// transient with a NULL layer delegate causes that primary window to be moved,
-// but the layer order not changed to match.  http://crbug.com/112562
-TEST_F(WindowTest, StackOverClosingTransient) {
-  scoped_ptr<Window> window1(CreateTestWindowWithId(1, root_window()));
-  scoped_ptr<Window> transient1(CreateTransientChild(11, window1.get()));
-  scoped_ptr<Window> window2(CreateTestWindowWithId(2, root_window()));
-  scoped_ptr<Window> transient2(CreateTransientChild(21, window2.get()));
-
-  // Both windows and layers are stacked in creation order.
-  Window* root = root_window();
-  ASSERT_EQ(4u, root->children().size());
-  EXPECT_EQ(root->children()[0], window1.get());
-  EXPECT_EQ(root->children()[1], transient1.get());
-  EXPECT_EQ(root->children()[2], window2.get());
-  EXPECT_EQ(root->children()[3], transient2.get());
-  ASSERT_EQ(4u, root->layer()->children().size());
-  EXPECT_EQ(root->layer()->children()[0], window1->layer());
-  EXPECT_EQ(root->layer()->children()[1], transient1->layer());
-  EXPECT_EQ(root->layer()->children()[2], window2->layer());
-  EXPECT_EQ(root->layer()->children()[3], transient2->layer());
-  EXPECT_EQ("1 11 2 21", ChildWindowIDsAsString(root_window()));
-
-  // This brings window1 and its transient to the front.
-  root->StackChildAtTop(window1.get());
-  EXPECT_EQ("2 21 1 11", ChildWindowIDsAsString(root_window()));
-
-  EXPECT_EQ(root->children()[0], window2.get());
-  EXPECT_EQ(root->children()[1], transient2.get());
-  EXPECT_EQ(root->children()[2], window1.get());
-  EXPECT_EQ(root->children()[3], transient1.get());
-  EXPECT_EQ(root->layer()->children()[0], window2->layer());
-  EXPECT_EQ(root->layer()->children()[1], transient2->layer());
-  EXPECT_EQ(root->layer()->children()[2], window1->layer());
-  EXPECT_EQ(root->layer()->children()[3], transient1->layer());
-
-  // Pretend we're closing the top-most transient, then bring window2 to the
-  // front.  This mimics activating a browser window while the status bubble
-  // is fading out.  The transient should stay topmost.
-  transient1->layer()->set_delegate(NULL);
-  root->StackChildAtTop(window2.get());
-
-  EXPECT_EQ(root->children()[0], window1.get());
-  EXPECT_EQ(root->children()[1], window2.get());
-  EXPECT_EQ(root->children()[2], transient2.get());
-  EXPECT_EQ(root->children()[3], transient1.get());
-  EXPECT_EQ(root->layer()->children()[0], window1->layer());
-  EXPECT_EQ(root->layer()->children()[1], window2->layer());
-  EXPECT_EQ(root->layer()->children()[2], transient2->layer());
-  EXPECT_EQ(root->layer()->children()[3], transient1->layer());
-
-  // Close the transient.  Remaining windows are stable.
-  transient1.reset();
-
-  ASSERT_EQ(3u, root->children().size());
-  EXPECT_EQ(root->children()[0], window1.get());
-  EXPECT_EQ(root->children()[1], window2.get());
-  EXPECT_EQ(root->children()[2], transient2.get());
-  ASSERT_EQ(3u, root->layer()->children().size());
-  EXPECT_EQ(root->layer()->children()[0], window1->layer());
-  EXPECT_EQ(root->layer()->children()[1], window2->layer());
-  EXPECT_EQ(root->layer()->children()[2], transient2->layer());
-
-  // Open another window on top.
-  scoped_ptr<Window> window3(CreateTestWindowWithId(3, root_window()));
-
-  ASSERT_EQ(4u, root->children().size());
-  EXPECT_EQ(root->children()[0], window1.get());
-  EXPECT_EQ(root->children()[1], window2.get());
-  EXPECT_EQ(root->children()[2], transient2.get());
-  EXPECT_EQ(root->children()[3], window3.get());
-  ASSERT_EQ(4u, root->layer()->children().size());
-  EXPECT_EQ(root->layer()->children()[0], window1->layer());
-  EXPECT_EQ(root->layer()->children()[1], window2->layer());
-  EXPECT_EQ(root->layer()->children()[2], transient2->layer());
-  EXPECT_EQ(root->layer()->children()[3], window3->layer());
-
-  // Pretend we're closing the topmost non-transient window, then bring
-  // window2 to the top.  It should not move.
-  window3->layer()->set_delegate(NULL);
-  root->StackChildAtTop(window2.get());
-
-  ASSERT_EQ(4u, root->children().size());
-  EXPECT_EQ(root->children()[0], window1.get());
-  EXPECT_EQ(root->children()[1], window2.get());
-  EXPECT_EQ(root->children()[2], transient2.get());
-  EXPECT_EQ(root->children()[3], window3.get());
-  ASSERT_EQ(4u, root->layer()->children().size());
-  EXPECT_EQ(root->layer()->children()[0], window1->layer());
-  EXPECT_EQ(root->layer()->children()[1], window2->layer());
-  EXPECT_EQ(root->layer()->children()[2], transient2->layer());
-  EXPECT_EQ(root->layer()->children()[3], window3->layer());
-
-  // Bring window1 to the top.  It should move ahead of window2, but not
-  // ahead of window3 (with NULL delegate).
-  root->StackChildAtTop(window1.get());
-
-  ASSERT_EQ(4u, root->children().size());
-  EXPECT_EQ(root->children()[0], window2.get());
-  EXPECT_EQ(root->children()[1], transient2.get());
-  EXPECT_EQ(root->children()[2], window1.get());
-  EXPECT_EQ(root->children()[3], window3.get());
-  ASSERT_EQ(4u, root->layer()->children().size());
-  EXPECT_EQ(root->layer()->children()[0], window2->layer());
-  EXPECT_EQ(root->layer()->children()[1], transient2->layer());
-  EXPECT_EQ(root->layer()->children()[2], window1->layer());
-  EXPECT_EQ(root->layer()->children()[3], window3->layer());
-}
-
 class RootWindowAttachmentObserver : public WindowObserver {
  public:
   RootWindowAttachmentObserver() : added_count_(0), removed_count_(0) {}
   virtual ~RootWindowAttachmentObserver() {}
 
   int added_count() const { return added_count_; }
   int removed_count() const { return removed_count_; }
 
   void Clear() {
     added_count_ = 0;
@@ skipping 500 matching lines @@
     o.ValidateState(index++, params);
     params.receiver = root_window();
     o.ValidateState(index++, params);
 
     w1.reset();
     w2.reset();
   }
 
 }
 
-namespace {
-
-// Used by NotifyDelegateAfterDeletingTransients. Adds a string to a vector when
-// OnWindowDestroyed() is invoked so that destruction order can be verified.
-class DestroyedTrackingDelegate : public TestWindowDelegate {
- public:
-  explicit DestroyedTrackingDelegate(const std::string& name,
-                                     std::vector<std::string>* results)
-      : name_(name),
-        results_(results) {}
-
-  virtual void OnWindowDestroyed() OVERRIDE {
-    results_->push_back(name_);
-  }
-
- private:
-  const std::string name_;
-  std::vector<std::string>* results_;
-
-  DISALLOW_COPY_AND_ASSIGN(DestroyedTrackingDelegate);
-};
-
-}  // namespace
-
-// Verifies the delegate is notified of destruction after transients are
-// destroyed.
-TEST_F(WindowTest, NotifyDelegateAfterDeletingTransients) {
-  std::vector<std::string> destruction_order;
-
-  DestroyedTrackingDelegate parent_delegate("parent", &destruction_order);
-  scoped_ptr<Window> parent(new Window(&parent_delegate));
-  parent->Init(ui::LAYER_NOT_DRAWN);
-
-  DestroyedTrackingDelegate transient_delegate("transient", &destruction_order);
-  Window* transient = new Window(&transient_delegate);  // Owned by |parent|.
-  transient->Init(ui::LAYER_NOT_DRAWN);
-  parent->AddTransientChild(transient);
-  parent.reset();
-
-  ASSERT_EQ(2u, destruction_order.size());
-  EXPECT_EQ("transient", destruction_order[0]);
-  EXPECT_EQ("parent", destruction_order[1]);
-}
-
 // Verifies SchedulePaint() on a layerless window results in damaging the right
 // thing.
 TEST_F(WindowTest, LayerlessWindowSchedulePaint) {
   Window root(NULL);
   root.Init(ui::LAYER_NOT_DRAWN);
   root.SetBounds(gfx::Rect(0, 0, 100, 100));
 
   Window* layerless_window = new Window(NULL);  // Owned by |root|.
   layerless_window->InitWithWindowLayerType(WINDOW_LAYER_NONE);
   layerless_window->SetBounds(gfx::Rect(10, 11, 12, 13));
@@ skipping 644 matching lines @@
               BuildRootLayerTreeDescription(*root.layer()))
         << "layer tree doesn't match at " << i;
     EXPECT_EQ(data[i].expected_description,
               BuildRootWindowTreeDescription(root))
         << "window tree doesn't match at " << i;
   }
 }
 
 }  // namespace test
 }  // namespace aura