| 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/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 | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 682713003:
Update a bunch of OWNERS files. (Closed)
Base URL: https://chromium.googlesource.com/chromium/src.git@master