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/v2/public/view.h" 6 7 #include "base/logging.h" 8 #include "testing/gtest/include/gtest/gtest.h" 9 #include "ui/compositor/layer.h" 10 #include "ui/compositor/layer_type.h" 11 12 namespace v2 { 13 14 // View ------------------------------------------------------------------------ 15 16 typedef testing::Test ViewTest; 17 18 TEST_F(ViewTest, AddChild) { 19 View v1; 20 View* v11 = new View; 21 v1.AddChild(v11); 22 EXPECT_EQ(1U, v1.children().size()); 23 } 24 25 TEST_F(ViewTest, RemoveChild) { 26 View v1; 27 View* v11 = new View; 28 v1.AddChild(v11); 29 EXPECT_EQ(1U, v1.children().size()); 30 v1.RemoveChild(v11); 31 EXPECT_EQ(0U, v1.children().size()); 32 } 33 34 TEST_F(ViewTest, Reparent) { 35 View v1; 36 View v2; 37 View* v11 = new View; 38 v1.AddChild(v11); 39 EXPECT_EQ(1U, v1.children().size()); 40 v2.AddChild(v11); 41 EXPECT_EQ(1U, v2.children().size()); 42 EXPECT_EQ(0U, v1.children().size()); 43 } 44 45 TEST_F(ViewTest, Contains) { 46 View v1; 47 48 // Direct descendant. 49 View* v11 = new View; 50 v1.AddChild(v11); 51 EXPECT_TRUE(v1.Contains(v11)); 52 53 // Indirect descendant. 54 View* v111 = new View; 55 v11->AddChild(v111); 56 EXPECT_TRUE(v1.Contains(v111)); 57 } 58 59 TEST_F(ViewTest, Stacking) { 60 View v1; 61 View* v11 = new View; 62 View* v12 = new View; 63 View* v13 = new View; 64 v1.AddChild(v11); 65 v1.AddChild(v12); 66 v1.AddChild(v13); 67 68 // Order: v11, v12, v13 69 EXPECT_EQ(3U, v1.children().size()); 70 EXPECT_EQ(v11, v1.children().front()); 71 EXPECT_EQ(v13, v1.children().back()); 72 73 // Move v11 to front. 74 // Resulting order: v12, v13, v11 75 v1.StackChildAtTop(v11); 76 EXPECT_EQ(v12, v1.children().front()); 77 EXPECT_EQ(v11, v1.children().back()); 78 79 // Move v11 to back. 80 // Resulting order: v11, v12, v13 81 v1.StackChildAtBottom(v11); 82 EXPECT_EQ(v11, v1.children().front()); 83 EXPECT_EQ(v13, v1.children().back()); 84 85 // Move v11 above v12. 86 // Resulting order: v12. v11, v13 87 v1.StackChildAbove(v11, v12); 88 EXPECT_EQ(v12, v1.children().front()); 89 EXPECT_EQ(v13, v1.children().back()); 90 91 // Move v11 below v12. 92 // Resulting order: v11, v12, v13 93 v1.StackChildBelow(v11, v12); 94 EXPECT_EQ(v11, v1.children().front()); 95 EXPECT_EQ(v13, v1.children().back()); 96 } 97 98 TEST_F(ViewTest, Layer) { 99 View v1; 100 v1.CreateLayer(ui::LAYER_NOT_DRAWN); 101 EXPECT_TRUE(v1.HasLayer()); 102 v1.DestroyLayer(); 103 EXPECT_FALSE(v1.HasLayer()); 104 105 v1.CreateLayer(ui::LAYER_NOT_DRAWN); 106 scoped_ptr<ui::Layer>(v1.AcquireLayer()); 107 // Acquiring the layer transfers ownership to the scoped_ptr above, so this 108 // test passes if it doesn't crash. 109 } 110 111 // ViewObserver ---------------------------------------------------------------- 112 113 typedef testing::Test ViewObserverTest; 114 115 bool TreeChangeParamsMatch(const ViewObserver::TreeChangeParams& lhs, 116 const ViewObserver::TreeChangeParams& rhs) { 117 return lhs.target == rhs.target && lhs.old_parent == rhs.old_parent && 118 lhs.new_parent == rhs.new_parent && lhs.receiver == rhs.receiver && 119 lhs.phase == rhs.phase; 120 } 121 122 class TreeChangeObserver : public ViewObserver { 123 public: 124 explicit TreeChangeObserver(View* observee) : observee_(observee) { 125 observee_->AddObserver(this); 126 } 127 virtual ~TreeChangeObserver() { 128 observee_->RemoveObserver(this); 129 } 130 131 void Reset() { 132 received_params_.clear(); 133 } 134 135 const std::vector<TreeChangeParams>& received_params() { 136 return received_params_; 137 } 138 139 private: 140 // Overridden from ViewObserver: 141 virtual void OnViewTreeChange(const TreeChangeParams& params) OVERRIDE { 142 received_params_.push_back(params); 143 } 144 145 View* observee_; 146 std::vector<TreeChangeParams> received_params_; 147 148 DISALLOW_COPY_AND_ASSIGN(TreeChangeObserver); 149 }; 150 151 // Adds/Removes v11 to v1. 152 TEST_F(ViewObserverTest, TreeChange_SimpleAddRemove) { 153 View v1; 154 TreeChangeObserver o1(&v1); 155 EXPECT_TRUE(o1.received_params().empty()); 156 157 View v11; 158 v11.set_owned_by_parent(false); 159 TreeChangeObserver o11(&v11); 160 EXPECT_TRUE(o11.received_params().empty()); 161 162 // Add. 163 164 v1.AddChild(&v11); 165 166 EXPECT_EQ(1U, o1.received_params().size()); 167 ViewObserver::TreeChangeParams p1; 168 p1.target = &v11; 169 p1.receiver = &v1; 170 p1.old_parent = NULL; 171 p1.new_parent = &v1; 172 p1.phase = ViewObserver::DISPOSITION_CHANGED; 173 EXPECT_TRUE(TreeChangeParamsMatch(p1, o1.received_params().back())); 174 175 EXPECT_EQ(2U, o11.received_params().size()); 176 ViewObserver::TreeChangeParams p11 = p1; 177 p11.receiver = &v11; 178 p11.phase = ViewObserver::DISPOSITION_CHANGING; 179 EXPECT_TRUE(TreeChangeParamsMatch(p11, o11.received_params().front())); 180 p11.phase = ViewObserver::DISPOSITION_CHANGED; 181 EXPECT_TRUE(TreeChangeParamsMatch(p11, o11.received_params().back())); 182 183 o1.Reset(); 184 o11.Reset(); 185 EXPECT_TRUE(o1.received_params().empty()); 186 EXPECT_TRUE(o11.received_params().empty()); 187 188 // Remove. 189 190 v1.RemoveChild(&v11); 191 192 EXPECT_EQ(1U, o1.received_params().size()); 193 p1.target = &v11; 194 p1.receiver = &v1; 195 p1.old_parent = &v1; 196 p1.new_parent = NULL; 197 p1.phase = ViewObserver::DISPOSITION_CHANGING; 198 EXPECT_TRUE(TreeChangeParamsMatch(p1, o1.received_params().back())); 199 200 EXPECT_EQ(2U, o11.received_params().size()); 201 p11 = p1; 202 p11.receiver = &v11; 203 EXPECT_TRUE(TreeChangeParamsMatch(p11, o11.received_params().front())); 204 p11.phase = ViewObserver::DISPOSITION_CHANGED; 205 EXPECT_TRUE(TreeChangeParamsMatch(p11, o11.received_params().back())); 206 } 207 208 // Creates these two trees: 209 // v1 210 // +- v11 211 // v111 212 // +- v1111 213 // +- v1112 214 // Then adds/removes v111 from v11. 215 TEST_F(ViewObserverTest, TreeChange_NestedAddRemove) { 216 View v1, v11, v111, v1111, v1112; 217 218 // Root tree. 219 v11.set_owned_by_parent(false); 220 v1.AddChild(&v11); 221 222 // Tree to be attached. 223 v111.set_owned_by_parent(false); 224 v1111.set_owned_by_parent(false); 225 v111.AddChild(&v1111); 226 v1112.set_owned_by_parent(false); 227 v111.AddChild(&v1112); 228 229 TreeChangeObserver o1(&v1), o11(&v11), o111(&v111), o1111(&v1111), 230 o1112(&v1112); 231 ViewObserver::TreeChangeParams p1, p11, p111, p1111, p1112; 232 233 // Add. 234 235 v11.AddChild(&v111); 236 237 EXPECT_EQ(1U, o1.received_params().size()); 238 p1.target = &v111; 239 p1.receiver = &v1; 240 p1.old_parent = NULL; 241 p1.new_parent = &v11; 242 p1.phase = ViewObserver::DISPOSITION_CHANGED; 243 EXPECT_TRUE(TreeChangeParamsMatch(p1, o1.received_params().back())); 244 245 EXPECT_EQ(1U, o11.received_params().size()); 246 p11 = p1; 247 p11.receiver = &v11; 248 EXPECT_TRUE(TreeChangeParamsMatch(p11, o11.received_params().back())); 249 250 EXPECT_EQ(2U, o111.received_params().size()); 251 p111 = p11; 252 p111.receiver = &v111; 253 p111.phase = ViewObserver::DISPOSITION_CHANGING; 254 EXPECT_TRUE(TreeChangeParamsMatch(p111, o111.received_params().front())); 255 p111.phase = ViewObserver::DISPOSITION_CHANGED; 256 EXPECT_TRUE(TreeChangeParamsMatch(p111, o111.received_params().back())); 257 258 EXPECT_EQ(2U, o1111.received_params().size()); 259 p1111 = p111; 260 p1111.receiver = &v1111; 261 p1111.phase = ViewObserver::DISPOSITION_CHANGING; 262 EXPECT_TRUE(TreeChangeParamsMatch(p1111, o1111.received_params().front())); 263 p1111.phase = ViewObserver::DISPOSITION_CHANGED; 264 EXPECT_TRUE(TreeChangeParamsMatch(p1111, o1111.received_params().back())); 265 266 EXPECT_EQ(2U, o1112.received_params().size()); 267 p1112 = p111; 268 p1112.receiver = &v1112; 269 p1112.phase = ViewObserver::DISPOSITION_CHANGING; 270 EXPECT_TRUE(TreeChangeParamsMatch(p1112, o1112.received_params().front())); 271 p1112.phase = ViewObserver::DISPOSITION_CHANGED; 272 EXPECT_TRUE(TreeChangeParamsMatch(p1112, o1112.received_params().back())); 273 274 // Remove. 275 o1.Reset(); 276 o11.Reset(); 277 o111.Reset(); 278 o1111.Reset(); 279 o1112.Reset(); 280 EXPECT_TRUE(o1.received_params().empty()); 281 EXPECT_TRUE(o11.received_params().empty()); 282 EXPECT_TRUE(o111.received_params().empty()); 283 EXPECT_TRUE(o1111.received_params().empty()); 284 EXPECT_TRUE(o1112.received_params().empty()); 285 286 v11.RemoveChild(&v111); 287 288 EXPECT_EQ(1U, o1.received_params().size()); 289 p1.target = &v111; 290 p1.receiver = &v1; 291 p1.old_parent = &v11; 292 p1.new_parent = NULL; 293 p1.phase = ViewObserver::DISPOSITION_CHANGING; 294 EXPECT_TRUE(TreeChangeParamsMatch(p1, o1.received_params().back())); 295 296 EXPECT_EQ(1U, o11.received_params().size()); 297 p11 = p1; 298 p11.receiver = &v11; 299 EXPECT_TRUE(TreeChangeParamsMatch(p11, o11.received_params().back())); 300 301 EXPECT_EQ(2U, o111.received_params().size()); 302 p111 = p11; 303 p111.receiver = &v111; 304 p111.phase = ViewObserver::DISPOSITION_CHANGING; 305 EXPECT_TRUE(TreeChangeParamsMatch(p111, o111.received_params().front())); 306 p111.phase = ViewObserver::DISPOSITION_CHANGED; 307 EXPECT_TRUE(TreeChangeParamsMatch(p111, o111.received_params().back())); 308 309 EXPECT_EQ(2U, o1111.received_params().size()); 310 p1111 = p111; 311 p1111.receiver = &v1111; 312 p1111.phase = ViewObserver::DISPOSITION_CHANGING; 313 EXPECT_TRUE(TreeChangeParamsMatch(p1111, o1111.received_params().front())); 314 p1111.phase = ViewObserver::DISPOSITION_CHANGED; 315 EXPECT_TRUE(TreeChangeParamsMatch(p1111, o1111.received_params().back())); 316 317 EXPECT_EQ(2U, o1112.received_params().size()); 318 p1112 = p111; 319 p1112.receiver = &v1112; 320 p1112.phase = ViewObserver::DISPOSITION_CHANGING; 321 EXPECT_TRUE(TreeChangeParamsMatch(p1112, o1112.received_params().front())); 322 p1112.phase = ViewObserver::DISPOSITION_CHANGED; 323 EXPECT_TRUE(TreeChangeParamsMatch(p1112, o1112.received_params().back())); 324 } 325 326 TEST_F(ViewObserverTest, TreeChange_Reparent) { 327 View v1, v11, v12, v111; 328 v11.set_owned_by_parent(false); 329 v111.set_owned_by_parent(false); 330 v12.set_owned_by_parent(false); 331 v1.AddChild(&v11); 332 v1.AddChild(&v12); 333 v11.AddChild(&v111); 334 335 TreeChangeObserver o1(&v1), o11(&v11), o12(&v12), o111(&v111); 336 337 // Reparent. 338 v12.AddChild(&v111); 339 340 // v1 (root) should see both changing and changed notifications. 341 EXPECT_EQ(2U, o1.received_params().size()); 342 ViewObserver::TreeChangeParams p1; 343 p1.target = &v111; 344 p1.receiver = &v1; 345 p1.old_parent = &v11; 346 p1.new_parent = &v12; 347 p1.phase = ViewObserver::DISPOSITION_CHANGING; 348 EXPECT_TRUE(TreeChangeParamsMatch(p1, o1.received_params().front())); 349 p1.phase = ViewObserver::DISPOSITION_CHANGED; 350 EXPECT_TRUE(TreeChangeParamsMatch(p1, o1.received_params().back())); 351 352 // v11 should see changing notifications. 353 EXPECT_EQ(1U, o11.received_params().size()); 354 ViewObserver::TreeChangeParams p11; 355 p11 = p1; 356 p11.receiver = &v11; 357 p11.phase = ViewObserver::DISPOSITION_CHANGING; 358 EXPECT_TRUE(TreeChangeParamsMatch(p11, o11.received_params().back())); 359 360 // v12 should see changed notifications. 361 EXPECT_EQ(1U, o12.received_params().size()); 362 ViewObserver::TreeChangeParams p12; 363 p12 = p1; 364 p12.receiver = &v12; 365 p12.phase = ViewObserver::DISPOSITION_CHANGED; 366 EXPECT_TRUE(TreeChangeParamsMatch(p12, o12.received_params().back())); 367 368 // v111 should see both changing and changed notifications. 369 EXPECT_EQ(2U, o111.received_params().size()); 370 ViewObserver::TreeChangeParams p111; 371 p111 = p1; 372 p111.receiver = &v111; 373 p111.phase = ViewObserver::DISPOSITION_CHANGING; 374 EXPECT_TRUE(TreeChangeParamsMatch(p111, o111.received_params().front())); 375 p111.phase = ViewObserver::DISPOSITION_CHANGED; 376 EXPECT_TRUE(TreeChangeParamsMatch(p111, o111.received_params().back())); 377 } 378 379 class VisibilityObserver : public ViewObserver { 380 public: 381 typedef std::pair<ViewObserver::DispositionChangePhase, bool> LogEntry; 382 typedef std::vector<LogEntry> LogEntries; 383 384 VisibilityObserver(View* view) : view_(view) { 385 view_->AddObserver(this); 386 } 387 virtual ~VisibilityObserver() { 388 view_->RemoveObserver(this); 389 } 390 391 const LogEntries& log_entries() const { return log_entries_; } 392 393 private: 394 // Overridden from ViewObserver: 395 virtual void OnViewVisibilityChange( 396 View* view, 397 ViewObserver::DispositionChangePhase phase) OVERRIDE { 398 DCHECK_EQ(view_, view); 399 log_entries_.push_back(std::make_pair(phase, view->visible())); 400 } 401 402 View* view_; 403 LogEntries log_entries_; 404 405 DISALLOW_COPY_AND_ASSIGN(VisibilityObserver); 406 }; 407 408 TEST_F(ViewObserverTest, VisibilityChange) { 409 View v1; // Starts out visible. 410 411 VisibilityObserver o1(&v1); 412 413 v1.SetVisible(false); 414 415 EXPECT_EQ(2U, o1.log_entries().size()); 416 EXPECT_EQ(ViewObserver::DISPOSITION_CHANGING, o1.log_entries().front().first); 417 EXPECT_EQ(o1.log_entries().front().second, true); 418 EXPECT_EQ(ViewObserver::DISPOSITION_CHANGED, o1.log_entries().back().first); 419 EXPECT_EQ(o1.log_entries().back().second, false); 420 } 421 422 class BoundsObserver : public ViewObserver { 423 public: 424 typedef std::pair<gfx::Rect, gfx::Rect> BoundsChange; 425 typedef std::vector<BoundsChange> BoundsChanges; 426 427 explicit BoundsObserver(View* view) : view_(view) { 428 view_->AddObserver(this); 429 } 430 virtual ~BoundsObserver() { 431 view_->RemoveObserver(this); 432 } 433 434 const BoundsChanges& bounds_changes() const { return bounds_changes_; } 435 436 private: 437 virtual void OnViewBoundsChanged(View* view, 438 const gfx::Rect& old_bounds, 439 const gfx::Rect& new_bounds) OVERRIDE { 440 DCHECK_EQ(view_, view); 441 bounds_changes_.push_back(std::make_pair(old_bounds, new_bounds)); 442 } 443 444 View* view_; 445 BoundsChanges bounds_changes_; 446 447 DISALLOW_COPY_AND_ASSIGN(BoundsObserver); 448 }; 449 450 TEST_F(ViewObserverTest, BoundsChanged) { 451 View v1; 452 BoundsObserver o1(&v1); 453 454 gfx::Rect new_bounds(0, 0, 10, 10); 455 456 v1.SetBounds(new_bounds); 457 EXPECT_EQ(1U, o1.bounds_changes().size()); 458 EXPECT_EQ(gfx::Rect(), o1.bounds_changes().front().first); 459 EXPECT_EQ(new_bounds, o1.bounds_changes().front().second); 460 } 461 462 } // namespace v2 463
