| OLD | NEW |
| (Empty) |
| 1 // Copyright (c) 2013 The Chromium Authors. All rights reserved. | |
| 2 // Use of this source code is governed by a BSD-style license that can be | |
| 3 // found in the LICENSE file. | |
| 4 | |
| 5 #include "ui/views/corewm/transient_window_stacking_client.h" | |
| 6 | |
| 7 #include "base/memory/scoped_ptr.h" | |
| 8 #include "ui/aura/test/aura_test_base.h" | |
| 9 #include "ui/aura/test/test_windows.h" | |
| 10 #include "ui/compositor/test/test_layers.h" | |
| 11 #include "ui/views/corewm/window_util.h" | |
| 12 | |
| 13 using aura::test::ChildWindowIDsAsString; | |
| 14 using aura::test::CreateTestWindowWithId; | |
| 15 using aura::Window; | |
| 16 | |
| 17 namespace views { | |
| 18 namespace corewm { | |
| 19 | |
| 20 class TransientWindowStackingClientTest : public aura::test::AuraTestBase { | |
| 21 public: | |
| 22 TransientWindowStackingClientTest() {} | |
| 23 virtual ~TransientWindowStackingClientTest() {} | |
| 24 | |
| 25 virtual void SetUp() OVERRIDE { | |
| 26 AuraTestBase::SetUp(); | |
| 27 client_.reset(new TransientWindowStackingClient); | |
| 28 aura::client::SetWindowStackingClient(client_.get()); | |
| 29 } | |
| 30 | |
| 31 virtual void TearDown() OVERRIDE { | |
| 32 aura::client::SetWindowStackingClient(NULL); | |
| 33 AuraTestBase::TearDown(); | |
| 34 } | |
| 35 | |
| 36 private: | |
| 37 scoped_ptr<TransientWindowStackingClient> client_; | |
| 38 DISALLOW_COPY_AND_ASSIGN(TransientWindowStackingClientTest); | |
| 39 }; | |
| 40 | |
| 41 // Tests that transient children are stacked as a unit when using stack above. | |
| 42 TEST_F(TransientWindowStackingClientTest, TransientChildrenGroupAbove) { | |
| 43 scoped_ptr<Window> parent(CreateTestWindowWithId(0, root_window())); | |
| 44 scoped_ptr<Window> w1(CreateTestWindowWithId(1, parent.get())); | |
| 45 Window* w11 = CreateTestWindowWithId(11, parent.get()); | |
| 46 scoped_ptr<Window> w2(CreateTestWindowWithId(2, parent.get())); | |
| 47 Window* w21 = CreateTestWindowWithId(21, parent.get()); | |
| 48 Window* w211 = CreateTestWindowWithId(211, parent.get()); | |
| 49 Window* w212 = CreateTestWindowWithId(212, parent.get()); | |
| 50 Window* w213 = CreateTestWindowWithId(213, parent.get()); | |
| 51 Window* w22 = CreateTestWindowWithId(22, parent.get()); | |
| 52 ASSERT_EQ(8u, parent->children().size()); | |
| 53 | |
| 54 AddTransientChild(w1.get(), w11); // w11 is now owned by w1. | |
| 55 AddTransientChild(w2.get(), w21); // w21 is now owned by w2. | |
| 56 AddTransientChild(w2.get(), w22); // w22 is now owned by w2. | |
| 57 AddTransientChild(w21, w211); // w211 is now owned by w21. | |
| 58 AddTransientChild(w21, w212); // w212 is now owned by w21. | |
| 59 AddTransientChild(w21, w213); // w213 is now owned by w21. | |
| 60 EXPECT_EQ("1 11 2 21 211 212 213 22", ChildWindowIDsAsString(parent.get())); | |
| 61 | |
| 62 // Stack w1 at the top (end), this should force w11 to be last (on top of w1). | |
| 63 parent->StackChildAtTop(w1.get()); | |
| 64 EXPECT_EQ(w11, parent->children().back()); | |
| 65 EXPECT_EQ("2 21 211 212 213 22 1 11", ChildWindowIDsAsString(parent.get())); | |
| 66 | |
| 67 // This tests that the order in children_ array rather than in | |
| 68 // transient_children_ array is used when reinserting transient children. | |
| 69 // If transient_children_ array was used '22' would be following '21'. | |
| 70 parent->StackChildAtTop(w2.get()); | |
| 71 EXPECT_EQ(w22, parent->children().back()); | |
| 72 EXPECT_EQ("1 11 2 21 211 212 213 22", ChildWindowIDsAsString(parent.get())); | |
| 73 | |
| 74 parent->StackChildAbove(w11, w2.get()); | |
| 75 EXPECT_EQ(w11, parent->children().back()); | |
| 76 EXPECT_EQ("2 21 211 212 213 22 1 11", ChildWindowIDsAsString(parent.get())); | |
| 77 | |
| 78 parent->StackChildAbove(w21, w1.get()); | |
| 79 EXPECT_EQ(w22, parent->children().back()); | |
| 80 EXPECT_EQ("1 11 2 21 211 212 213 22", ChildWindowIDsAsString(parent.get())); | |
| 81 | |
| 82 parent->StackChildAbove(w21, w22); | |
| 83 EXPECT_EQ(w213, parent->children().back()); | |
| 84 EXPECT_EQ("1 11 2 22 21 211 212 213", ChildWindowIDsAsString(parent.get())); | |
| 85 | |
| 86 parent->StackChildAbove(w11, w21); | |
| 87 EXPECT_EQ(w11, parent->children().back()); | |
| 88 EXPECT_EQ("2 22 21 211 212 213 1 11", ChildWindowIDsAsString(parent.get())); | |
| 89 | |
| 90 parent->StackChildAbove(w213, w21); | |
| 91 EXPECT_EQ(w11, parent->children().back()); | |
| 92 EXPECT_EQ("2 22 21 213 211 212 1 11", ChildWindowIDsAsString(parent.get())); | |
| 93 | |
| 94 // No change when stacking a transient parent above its transient child. | |
| 95 parent->StackChildAbove(w21, w211); | |
| 96 EXPECT_EQ(w11, parent->children().back()); | |
| 97 EXPECT_EQ("2 22 21 213 211 212 1 11", ChildWindowIDsAsString(parent.get())); | |
| 98 | |
| 99 // This tests that the order in children_ array rather than in | |
| 100 // transient_children_ array is used when reinserting transient children. | |
| 101 // If transient_children_ array was used '22' would be following '21'. | |
| 102 parent->StackChildAbove(w2.get(), w1.get()); | |
| 103 EXPECT_EQ(w212, parent->children().back()); | |
| 104 EXPECT_EQ("1 11 2 22 21 213 211 212", ChildWindowIDsAsString(parent.get())); | |
| 105 | |
| 106 parent->StackChildAbove(w11, w213); | |
| 107 EXPECT_EQ(w11, parent->children().back()); | |
| 108 EXPECT_EQ("2 22 21 213 211 212 1 11", ChildWindowIDsAsString(parent.get())); | |
| 109 } | |
| 110 | |
| 111 // Tests that transient children are stacked as a unit when using stack below. | |
| 112 TEST_F(TransientWindowStackingClientTest, TransientChildrenGroupBelow) { | |
| 113 scoped_ptr<Window> parent(CreateTestWindowWithId(0, root_window())); | |
| 114 scoped_ptr<Window> w1(CreateTestWindowWithId(1, parent.get())); | |
| 115 Window* w11 = CreateTestWindowWithId(11, parent.get()); | |
| 116 scoped_ptr<Window> w2(CreateTestWindowWithId(2, parent.get())); | |
| 117 Window* w21 = CreateTestWindowWithId(21, parent.get()); | |
| 118 Window* w211 = CreateTestWindowWithId(211, parent.get()); | |
| 119 Window* w212 = CreateTestWindowWithId(212, parent.get()); | |
| 120 Window* w213 = CreateTestWindowWithId(213, parent.get()); | |
| 121 Window* w22 = CreateTestWindowWithId(22, parent.get()); | |
| 122 ASSERT_EQ(8u, parent->children().size()); | |
| 123 | |
| 124 AddTransientChild(w1.get(), w11); // w11 is now owned by w1. | |
| 125 AddTransientChild(w2.get(), w21); // w21 is now owned by w2. | |
| 126 AddTransientChild(w2.get(), w22); // w22 is now owned by w2. | |
| 127 AddTransientChild(w21, w211); // w211 is now owned by w21. | |
| 128 AddTransientChild(w21, w212); // w212 is now owned by w21. | |
| 129 AddTransientChild(w21, w213); // w213 is now owned by w21. | |
| 130 EXPECT_EQ("1 11 2 21 211 212 213 22", ChildWindowIDsAsString(parent.get())); | |
| 131 | |
| 132 // Stack w2 at the bottom, this should force w11 to be last (on top of w1). | |
| 133 // This also tests that the order in children_ array rather than in | |
| 134 // transient_children_ array is used when reinserting transient children. | |
| 135 // If transient_children_ array was used '22' would be following '21'. | |
| 136 parent->StackChildAtBottom(w2.get()); | |
| 137 EXPECT_EQ(w11, parent->children().back()); | |
| 138 EXPECT_EQ("2 21 211 212 213 22 1 11", ChildWindowIDsAsString(parent.get())); | |
| 139 | |
| 140 parent->StackChildAtBottom(w1.get()); | |
| 141 EXPECT_EQ(w22, parent->children().back()); | |
| 142 EXPECT_EQ("1 11 2 21 211 212 213 22", ChildWindowIDsAsString(parent.get())); | |
| 143 | |
| 144 parent->StackChildBelow(w21, w1.get()); | |
| 145 EXPECT_EQ(w11, parent->children().back()); | |
| 146 EXPECT_EQ("2 21 211 212 213 22 1 11", ChildWindowIDsAsString(parent.get())); | |
| 147 | |
| 148 parent->StackChildBelow(w11, w2.get()); | |
| 149 EXPECT_EQ(w22, parent->children().back()); | |
| 150 EXPECT_EQ("1 11 2 21 211 212 213 22", ChildWindowIDsAsString(parent.get())); | |
| 151 | |
| 152 parent->StackChildBelow(w22, w21); | |
| 153 EXPECT_EQ(w213, parent->children().back()); | |
| 154 EXPECT_EQ("1 11 2 22 21 211 212 213", ChildWindowIDsAsString(parent.get())); | |
| 155 | |
| 156 parent->StackChildBelow(w21, w11); | |
| 157 EXPECT_EQ(w11, parent->children().back()); | |
| 158 EXPECT_EQ("2 22 21 211 212 213 1 11", ChildWindowIDsAsString(parent.get())); | |
| 159 | |
| 160 parent->StackChildBelow(w213, w211); | |
| 161 EXPECT_EQ(w11, parent->children().back()); | |
| 162 EXPECT_EQ("2 22 21 213 211 212 1 11", ChildWindowIDsAsString(parent.get())); | |
| 163 | |
| 164 // No change when stacking a transient parent below its transient child. | |
| 165 parent->StackChildBelow(w21, w211); | |
| 166 EXPECT_EQ(w11, parent->children().back()); | |
| 167 EXPECT_EQ("2 22 21 213 211 212 1 11", ChildWindowIDsAsString(parent.get())); | |
| 168 | |
| 169 parent->StackChildBelow(w1.get(), w2.get()); | |
| 170 EXPECT_EQ(w212, parent->children().back()); | |
| 171 EXPECT_EQ("1 11 2 22 21 213 211 212", ChildWindowIDsAsString(parent.get())); | |
| 172 | |
| 173 parent->StackChildBelow(w213, w11); | |
| 174 EXPECT_EQ(w11, parent->children().back()); | |
| 175 EXPECT_EQ("2 22 21 213 211 212 1 11", ChildWindowIDsAsString(parent.get())); | |
| 176 } | |
| 177 | |
| 178 TEST_F(TransientWindowStackingClientTest, | |
| 179 StackWindowsWhoseLayersHaveNoDelegate) { | |
| 180 scoped_ptr<Window> window1(CreateTestWindowWithId(1, root_window())); | |
| 181 window1->layer()->set_name("1"); | |
| 182 scoped_ptr<Window> window2(CreateTestWindowWithId(2, root_window())); | |
| 183 window2->layer()->set_name("2"); | |
| 184 scoped_ptr<Window> window3(CreateTestWindowWithId(3, root_window())); | |
| 185 window3->layer()->set_name("3"); | |
| 186 | |
| 187 // This brings |window1| (and its layer) to the front. | |
| 188 root_window()->StackChildAbove(window1.get(), window3.get()); | |
| 189 EXPECT_EQ("2 3 1", ChildWindowIDsAsString(root_window())); | |
| 190 EXPECT_EQ("2 3 1", | |
| 191 ui::test::ChildLayerNamesAsString(*root_window()->layer())); | |
| 192 | |
| 193 // Since |window1| does not have a delegate, |window2| should not move in | |
| 194 // front of it, nor should its layer. | |
| 195 window1->layer()->set_delegate(NULL); | |
| 196 root_window()->StackChildAbove(window2.get(), window1.get()); | |
| 197 EXPECT_EQ("3 2 1", ChildWindowIDsAsString(root_window())); | |
| 198 EXPECT_EQ("3 2 1", | |
| 199 ui::test::ChildLayerNamesAsString(*root_window()->layer())); | |
| 200 | |
| 201 // It should still be possible to stack |window3| immediately below |window1|. | |
| 202 root_window()->StackChildBelow(window3.get(), window1.get()); | |
| 203 EXPECT_EQ("2 3 1", ChildWindowIDsAsString(root_window())); | |
| 204 EXPECT_EQ("2 3 1", | |
| 205 ui::test::ChildLayerNamesAsString(*root_window()->layer())); | |
| 206 | |
| 207 // Since neither |window3| nor |window1| have a delegate, |window2| should | |
| 208 // not move in front of either. | |
| 209 window3->layer()->set_delegate(NULL); | |
| 210 root_window()->StackChildBelow(window2.get(), window1.get()); | |
| 211 EXPECT_EQ("2 3 1", ChildWindowIDsAsString(root_window())); | |
| 212 EXPECT_EQ("2 3 1", | |
| 213 ui::test::ChildLayerNamesAsString(*root_window()->layer())); | |
| 214 } | |
| 215 | |
| 216 } // namespace corewm | |
| 217 } // namespace views | |
| OLD | NEW |