| OLD | NEW |
|---|
| (Empty) |
| 1 // Copyright 2014 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 "mojo/services/public/cpp/view_manager/node.h" | |
| 6 | |
| 7 #include "base/logging.h" | |
| 8 #include "base/strings/stringprintf.h" | |
| 9 #include "mojo/services/public/cpp/view_manager/lib/node_private.h" | |
| 10 #include "mojo/services/public/cpp/view_manager/node_observer.h" | |
| 11 #include "mojo/services/public/cpp/view_manager/util.h" | |
| 12 #include "testing/gtest/include/gtest/gtest.h" | |
| 13 | |
| 14 namespace mojo { | |
| 15 | |
| 16 // Node ------------------------------------------------------------------------ | |
| 17 | |
| 18 typedef testing::Test NodeTest; | |
| 19 | |
| 20 // Subclass with public ctor/dtor. | |
| 21 class TestNode : public Node { | |
| 22 public: | |
| 23 TestNode() { | |
| 24 NodePrivate(this).set_id(1); | |
| 25 } | |
| 26 ~TestNode() {} | |
| 27 | |
| 28 private: | |
| 29 DISALLOW_COPY_AND_ASSIGN(TestNode); | |
| 30 }; | |
| 31 | |
| 32 TEST_F(NodeTest, AddChild) { | |
| 33 TestNode v1; | |
| 34 TestNode v11; | |
| 35 v1.AddChild(&v11); | |
| 36 EXPECT_EQ(1U, v1.children().size()); | |
| 37 } | |
| 38 | |
| 39 TEST_F(NodeTest, RemoveChild) { | |
| 40 TestNode v1; | |
| 41 TestNode v11; | |
| 42 v1.AddChild(&v11); | |
| 43 EXPECT_EQ(1U, v1.children().size()); | |
| 44 v1.RemoveChild(&v11); | |
| 45 EXPECT_EQ(0U, v1.children().size()); | |
| 46 } | |
| 47 | |
| 48 TEST_F(NodeTest, Reparent) { | |
| 49 TestNode v1; | |
| 50 TestNode v2; | |
| 51 TestNode v11; | |
| 52 v1.AddChild(&v11); | |
| 53 EXPECT_EQ(1U, v1.children().size()); | |
| 54 v2.AddChild(&v11); | |
| 55 EXPECT_EQ(1U, v2.children().size()); | |
| 56 EXPECT_EQ(0U, v1.children().size()); | |
| 57 } | |
| 58 | |
| 59 TEST_F(NodeTest, Contains) { | |
| 60 TestNode v1; | |
| 61 | |
| 62 // Direct descendant. | |
| 63 TestNode v11; | |
| 64 v1.AddChild(&v11); | |
| 65 EXPECT_TRUE(v1.Contains(&v11)); | |
| 66 | |
| 67 // Indirect descendant. | |
| 68 TestNode v111; | |
| 69 v11.AddChild(&v111); | |
| 70 EXPECT_TRUE(v1.Contains(&v111)); | |
| 71 } | |
| 72 | |
| 73 TEST_F(NodeTest, GetChildById) { | |
| 74 TestNode v1; | |
| 75 NodePrivate(&v1).set_id(1); | |
| 76 TestNode v11; | |
| 77 NodePrivate(&v11).set_id(11); | |
| 78 v1.AddChild(&v11); | |
| 79 TestNode v111; | |
| 80 NodePrivate(&v111).set_id(111); | |
| 81 v11.AddChild(&v111); | |
| 82 | |
| 83 // Find direct & indirect descendents. | |
| 84 EXPECT_EQ(&v11, v1.GetChildById(v11.id())); | |
| 85 EXPECT_EQ(&v111, v1.GetChildById(v111.id())); | |
| 86 } | |
| 87 | |
| 88 // NodeObserver -------------------------------------------------------- | |
| 89 | |
| 90 typedef testing::Test NodeObserverTest; | |
| 91 | |
| 92 bool TreeChangeParamsMatch(const NodeObserver::TreeChangeParams& lhs, | |
| 93 const NodeObserver::TreeChangeParams& rhs) { | |
| 94 return lhs.target == rhs.target && lhs.old_parent == rhs.old_parent && | |
| 95 lhs.new_parent == rhs.new_parent && lhs.receiver == rhs.receiver; | |
| 96 } | |
| 97 | |
| 98 class TreeChangeObserver : public NodeObserver { | |
| 99 public: | |
| 100 explicit TreeChangeObserver(Node* observee) : observee_(observee) { | |
| 101 observee_->AddObserver(this); | |
| 102 } | |
| 103 virtual ~TreeChangeObserver() { | |
| 104 observee_->RemoveObserver(this); | |
| 105 } | |
| 106 | |
| 107 void Reset() { | |
| 108 received_params_.clear(); | |
| 109 } | |
| 110 | |
| 111 const std::vector<TreeChangeParams>& received_params() { | |
| 112 return received_params_; | |
| 113 } | |
| 114 | |
| 115 private: | |
| 116 // Overridden from NodeObserver: | |
| 117 virtual void OnTreeChanging(const TreeChangeParams& params) OVERRIDE { | |
| 118 received_params_.push_back(params); | |
| 119 } | |
| 120 virtual void OnTreeChanged(const TreeChangeParams& params) OVERRIDE { | |
| 121 received_params_.push_back(params); | |
| 122 } | |
| 123 | |
| 124 Node* observee_; | |
| 125 std::vector<TreeChangeParams> received_params_; | |
| 126 | |
| 127 DISALLOW_COPY_AND_ASSIGN(TreeChangeObserver); | |
| 128 }; | |
| 129 | |
| 130 // Adds/Removes v11 to v1. | |
| 131 TEST_F(NodeObserverTest, TreeChange_SimpleAddRemove) { | |
| 132 TestNode v1; | |
| 133 TreeChangeObserver o1(&v1); | |
| 134 EXPECT_TRUE(o1.received_params().empty()); | |
| 135 | |
| 136 TestNode v11; | |
| 137 TreeChangeObserver o11(&v11); | |
| 138 EXPECT_TRUE(o11.received_params().empty()); | |
| 139 | |
| 140 // Add. | |
| 141 | |
| 142 v1.AddChild(&v11); | |
| 143 | |
| 144 EXPECT_EQ(2U, o1.received_params().size()); | |
| 145 NodeObserver::TreeChangeParams p1; | |
| 146 p1.target = &v11; | |
| 147 p1.receiver = &v1; | |
| 148 p1.old_parent = NULL; | |
| 149 p1.new_parent = &v1; | |
| 150 EXPECT_TRUE(TreeChangeParamsMatch(p1, o1.received_params().back())); | |
| 151 | |
| 152 EXPECT_EQ(2U, o11.received_params().size()); | |
| 153 NodeObserver::TreeChangeParams p11 = p1; | |
| 154 p11.receiver = &v11; | |
| 155 EXPECT_TRUE(TreeChangeParamsMatch(p11, o11.received_params().front())); | |
| 156 EXPECT_TRUE(TreeChangeParamsMatch(p11, o11.received_params().back())); | |
| 157 | |
| 158 o1.Reset(); | |
| 159 o11.Reset(); | |
| 160 EXPECT_TRUE(o1.received_params().empty()); | |
| 161 EXPECT_TRUE(o11.received_params().empty()); | |
| 162 | |
| 163 // Remove. | |
| 164 | |
| 165 v1.RemoveChild(&v11); | |
| 166 | |
| 167 EXPECT_EQ(2U, o1.received_params().size()); | |
| 168 p1.target = &v11; | |
| 169 p1.receiver = &v1; | |
| 170 p1.old_parent = &v1; | |
| 171 p1.new_parent = NULL; | |
| 172 EXPECT_TRUE(TreeChangeParamsMatch(p1, o1.received_params().front())); | |
| 173 | |
| 174 EXPECT_EQ(2U, o11.received_params().size()); | |
| 175 p11 = p1; | |
| 176 p11.receiver = &v11; | |
| 177 EXPECT_TRUE(TreeChangeParamsMatch(p11, o11.received_params().front())); | |
| 178 EXPECT_TRUE(TreeChangeParamsMatch(p11, o11.received_params().back())); | |
| 179 } | |
| 180 | |
| 181 // Creates these two trees: | |
| 182 // v1 | |
| 183 // +- v11 | |
| 184 // v111 | |
| 185 // +- v1111 | |
| 186 // +- v1112 | |
| 187 // Then adds/removes v111 from v11. | |
| 188 TEST_F(NodeObserverTest, TreeChange_NestedAddRemove) { | |
| 189 TestNode v1, v11, v111, v1111, v1112; | |
| 190 | |
| 191 // Root tree. | |
| 192 v1.AddChild(&v11); | |
| 193 | |
| 194 // Tree to be attached. | |
| 195 v111.AddChild(&v1111); | |
| 196 v111.AddChild(&v1112); | |
| 197 | |
| 198 TreeChangeObserver o1(&v1), o11(&v11), o111(&v111), o1111(&v1111), | |
| 199 o1112(&v1112); | |
| 200 NodeObserver::TreeChangeParams p1, p11, p111, p1111, p1112; | |
| 201 | |
| 202 // Add. | |
| 203 | |
| 204 v11.AddChild(&v111); | |
| 205 | |
| 206 EXPECT_EQ(2U, o1.received_params().size()); | |
| 207 p1.target = &v111; | |
| 208 p1.receiver = &v1; | |
| 209 p1.old_parent = NULL; | |
| 210 p1.new_parent = &v11; | |
| 211 EXPECT_TRUE(TreeChangeParamsMatch(p1, o1.received_params().back())); | |
| 212 | |
| 213 EXPECT_EQ(2U, o11.received_params().size()); | |
| 214 p11 = p1; | |
| 215 p11.receiver = &v11; | |
| 216 EXPECT_TRUE(TreeChangeParamsMatch(p11, o11.received_params().back())); | |
| 217 | |
| 218 EXPECT_EQ(2U, o111.received_params().size()); | |
| 219 p111 = p11; | |
| 220 p111.receiver = &v111; | |
| 221 EXPECT_TRUE(TreeChangeParamsMatch(p111, o111.received_params().front())); | |
| 222 EXPECT_TRUE(TreeChangeParamsMatch(p111, o111.received_params().back())); | |
| 223 | |
| 224 EXPECT_EQ(2U, o1111.received_params().size()); | |
| 225 p1111 = p111; | |
| 226 p1111.receiver = &v1111; | |
| 227 EXPECT_TRUE(TreeChangeParamsMatch(p1111, o1111.received_params().front())); | |
| 228 EXPECT_TRUE(TreeChangeParamsMatch(p1111, o1111.received_params().back())); | |
| 229 | |
| 230 EXPECT_EQ(2U, o1112.received_params().size()); | |
| 231 p1112 = p111; | |
| 232 p1112.receiver = &v1112; | |
| 233 EXPECT_TRUE(TreeChangeParamsMatch(p1112, o1112.received_params().front())); | |
| 234 EXPECT_TRUE(TreeChangeParamsMatch(p1112, o1112.received_params().back())); | |
| 235 | |
| 236 // Remove. | |
| 237 o1.Reset(); | |
| 238 o11.Reset(); | |
| 239 o111.Reset(); | |
| 240 o1111.Reset(); | |
| 241 o1112.Reset(); | |
| 242 EXPECT_TRUE(o1.received_params().empty()); | |
| 243 EXPECT_TRUE(o11.received_params().empty()); | |
| 244 EXPECT_TRUE(o111.received_params().empty()); | |
| 245 EXPECT_TRUE(o1111.received_params().empty()); | |
| 246 EXPECT_TRUE(o1112.received_params().empty()); | |
| 247 | |
| 248 v11.RemoveChild(&v111); | |
| 249 | |
| 250 EXPECT_EQ(2U, o1.received_params().size()); | |
| 251 p1.target = &v111; | |
| 252 p1.receiver = &v1; | |
| 253 p1.old_parent = &v11; | |
| 254 p1.new_parent = NULL; | |
| 255 EXPECT_TRUE(TreeChangeParamsMatch(p1, o1.received_params().front())); | |
| 256 | |
| 257 EXPECT_EQ(2U, o11.received_params().size()); | |
| 258 p11 = p1; | |
| 259 p11.receiver = &v11; | |
| 260 EXPECT_TRUE(TreeChangeParamsMatch(p11, o11.received_params().front())); | |
| 261 | |
| 262 EXPECT_EQ(2U, o111.received_params().size()); | |
| 263 p111 = p11; | |
| 264 p111.receiver = &v111; | |
| 265 EXPECT_TRUE(TreeChangeParamsMatch(p111, o111.received_params().front())); | |
| 266 EXPECT_TRUE(TreeChangeParamsMatch(p111, o111.received_params().back())); | |
| 267 | |
| 268 EXPECT_EQ(2U, o1111.received_params().size()); | |
| 269 p1111 = p111; | |
| 270 p1111.receiver = &v1111; | |
| 271 EXPECT_TRUE(TreeChangeParamsMatch(p1111, o1111.received_params().front())); | |
| 272 EXPECT_TRUE(TreeChangeParamsMatch(p1111, o1111.received_params().back())); | |
| 273 | |
| 274 EXPECT_EQ(2U, o1112.received_params().size()); | |
| 275 p1112 = p111; | |
| 276 p1112.receiver = &v1112; | |
| 277 EXPECT_TRUE(TreeChangeParamsMatch(p1112, o1112.received_params().front())); | |
| 278 EXPECT_TRUE(TreeChangeParamsMatch(p1112, o1112.received_params().back())); | |
| 279 } | |
| 280 | |
| 281 TEST_F(NodeObserverTest, TreeChange_Reparent) { | |
| 282 TestNode v1, v11, v12, v111; | |
| 283 v1.AddChild(&v11); | |
| 284 v1.AddChild(&v12); | |
| 285 v11.AddChild(&v111); | |
| 286 | |
| 287 TreeChangeObserver o1(&v1), o11(&v11), o12(&v12), o111(&v111); | |
| 288 | |
| 289 // Reparent. | |
| 290 v12.AddChild(&v111); | |
| 291 | |
| 292 // v1 (root) should see both changing and changed notifications. | |
| 293 EXPECT_EQ(4U, o1.received_params().size()); | |
| 294 NodeObserver::TreeChangeParams p1; | |
| 295 p1.target = &v111; | |
| 296 p1.receiver = &v1; | |
| 297 p1.old_parent = &v11; | |
| 298 p1.new_parent = &v12; | |
| 299 EXPECT_TRUE(TreeChangeParamsMatch(p1, o1.received_params().front())); | |
| 300 EXPECT_TRUE(TreeChangeParamsMatch(p1, o1.received_params().back())); | |
| 301 | |
| 302 // v11 should see changing notifications. | |
| 303 EXPECT_EQ(2U, o11.received_params().size()); | |
| 304 NodeObserver::TreeChangeParams p11; | |
| 305 p11 = p1; | |
| 306 p11.receiver = &v11; | |
| 307 EXPECT_TRUE(TreeChangeParamsMatch(p11, o11.received_params().front())); | |
| 308 | |
| 309 // v12 should see changed notifications. | |
| 310 EXPECT_EQ(2U, o12.received_params().size()); | |
| 311 NodeObserver::TreeChangeParams p12; | |
| 312 p12 = p1; | |
| 313 p12.receiver = &v12; | |
| 314 EXPECT_TRUE(TreeChangeParamsMatch(p12, o12.received_params().back())); | |
| 315 | |
| 316 // v111 should see both changing and changed notifications. | |
| 317 EXPECT_EQ(2U, o111.received_params().size()); | |
| 318 NodeObserver::TreeChangeParams p111; | |
| 319 p111 = p1; | |
| 320 p111.receiver = &v111; | |
| 321 EXPECT_TRUE(TreeChangeParamsMatch(p111, o111.received_params().front())); | |
| 322 EXPECT_TRUE(TreeChangeParamsMatch(p111, o111.received_params().back())); | |
| 323 } | |
| 324 | |
| 325 namespace { | |
| 326 | |
| 327 class OrderChangeObserver : public NodeObserver { | |
| 328 public: | |
| 329 struct Change { | |
| 330 Node* node; | |
| 331 Node* relative_node; | |
| 332 OrderDirection direction; | |
| 333 }; | |
| 334 typedef std::vector<Change> Changes; | |
| 335 | |
| 336 explicit OrderChangeObserver(Node* observee) : observee_(observee) { | |
| 337 observee_->AddObserver(this); | |
| 338 } | |
| 339 virtual ~OrderChangeObserver() { | |
| 340 observee_->RemoveObserver(this); | |
| 341 } | |
| 342 | |
| 343 Changes GetAndClearChanges() { | |
| 344 Changes changes; | |
| 345 changes_.swap(changes); | |
| 346 return changes; | |
| 347 } | |
| 348 | |
| 349 private: | |
| 350 // Overridden from NodeObserver: | |
| 351 virtual void OnNodeReordering(Node* node, | |
| 352 Node* relative_node, | |
| 353 OrderDirection direction) OVERRIDE { | |
| 354 OnNodeReordered(node, relative_node, direction); | |
| 355 } | |
| 356 | |
| 357 virtual void OnNodeReordered(Node* node, | |
| 358 Node* relative_node, | |
| 359 OrderDirection direction) OVERRIDE { | |
| 360 Change change; | |
| 361 change.node = node; | |
| 362 change.relative_node = relative_node; | |
| 363 change.direction = direction; | |
| 364 changes_.push_back(change); | |
| 365 } | |
| 366 | |
| 367 Node* observee_; | |
| 368 Changes changes_; | |
| 369 | |
| 370 DISALLOW_COPY_AND_ASSIGN(OrderChangeObserver); | |
| 371 }; | |
| 372 | |
| 373 } // namespace | |
| 374 | |
| 375 TEST_F(NodeObserverTest, Order) { | |
| 376 TestNode v1, v11, v12, v13; | |
| 377 v1.AddChild(&v11); | |
| 378 v1.AddChild(&v12); | |
| 379 v1.AddChild(&v13); | |
| 380 | |
| 381 // Order: v11, v12, v13 | |
| 382 EXPECT_EQ(3U, v1.children().size()); | |
| 383 EXPECT_EQ(&v11, v1.children().front()); | |
| 384 EXPECT_EQ(&v13, v1.children().back()); | |
| 385 | |
| 386 { | |
| 387 OrderChangeObserver observer(&v11); | |
| 388 | |
| 389 // Move v11 to front. | |
| 390 // Resulting order: v12, v13, v11 | |
| 391 v11.MoveToFront(); | |
| 392 EXPECT_EQ(&v12, v1.children().front()); | |
| 393 EXPECT_EQ(&v11, v1.children().back()); | |
| 394 | |
| 395 OrderChangeObserver::Changes changes = observer.GetAndClearChanges(); | |
| 396 EXPECT_EQ(2U, changes.size()); | |
| 397 EXPECT_EQ(&v11, changes[0].node); | |
| 398 EXPECT_EQ(&v13, changes[0].relative_node); | |
| 399 EXPECT_EQ(ORDER_DIRECTION_ABOVE, changes[0].direction); | |
| 400 | |
| 401 EXPECT_EQ(&v11, changes[1].node); | |
| 402 EXPECT_EQ(&v13, changes[1].relative_node); | |
| 403 EXPECT_EQ(ORDER_DIRECTION_ABOVE, changes[1].direction); | |
| 404 } | |
| 405 | |
| 406 { | |
| 407 OrderChangeObserver observer(&v11); | |
| 408 | |
| 409 // Move v11 to back. | |
| 410 // Resulting order: v11, v12, v13 | |
| 411 v11.MoveToBack(); | |
| 412 EXPECT_EQ(&v11, v1.children().front()); | |
| 413 EXPECT_EQ(&v13, v1.children().back()); | |
| 414 | |
| 415 OrderChangeObserver::Changes changes = observer.GetAndClearChanges(); | |
| 416 EXPECT_EQ(2U, changes.size()); | |
| 417 EXPECT_EQ(&v11, changes[0].node); | |
| 418 EXPECT_EQ(&v12, changes[0].relative_node); | |
| 419 EXPECT_EQ(ORDER_DIRECTION_BELOW, changes[0].direction); | |
| 420 | |
| 421 EXPECT_EQ(&v11, changes[1].node); | |
| 422 EXPECT_EQ(&v12, changes[1].relative_node); | |
| 423 EXPECT_EQ(ORDER_DIRECTION_BELOW, changes[1].direction); | |
| 424 } | |
| 425 | |
| 426 { | |
| 427 OrderChangeObserver observer(&v11); | |
| 428 | |
| 429 // Move v11 above v12. | |
| 430 // Resulting order: v12. v11, v13 | |
| 431 v11.Reorder(&v12, ORDER_DIRECTION_ABOVE); | |
| 432 EXPECT_EQ(&v12, v1.children().front()); | |
| 433 EXPECT_EQ(&v13, v1.children().back()); | |
| 434 | |
| 435 OrderChangeObserver::Changes changes = observer.GetAndClearChanges(); | |
| 436 EXPECT_EQ(2U, changes.size()); | |
| 437 EXPECT_EQ(&v11, changes[0].node); | |
| 438 EXPECT_EQ(&v12, changes[0].relative_node); | |
| 439 EXPECT_EQ(ORDER_DIRECTION_ABOVE, changes[0].direction); | |
| 440 | |
| 441 EXPECT_EQ(&v11, changes[1].node); | |
| 442 EXPECT_EQ(&v12, changes[1].relative_node); | |
| 443 EXPECT_EQ(ORDER_DIRECTION_ABOVE, changes[1].direction); | |
| 444 } | |
| 445 | |
| 446 { | |
| 447 OrderChangeObserver observer(&v11); | |
| 448 | |
| 449 // Move v11 below v12. | |
| 450 // Resulting order: v11, v12, v13 | |
| 451 v11.Reorder(&v12, ORDER_DIRECTION_BELOW); | |
| 452 EXPECT_EQ(&v11, v1.children().front()); | |
| 453 EXPECT_EQ(&v13, v1.children().back()); | |
| 454 | |
| 455 OrderChangeObserver::Changes changes = observer.GetAndClearChanges(); | |
| 456 EXPECT_EQ(2U, changes.size()); | |
| 457 EXPECT_EQ(&v11, changes[0].node); | |
| 458 EXPECT_EQ(&v12, changes[0].relative_node); | |
| 459 EXPECT_EQ(ORDER_DIRECTION_BELOW, changes[0].direction); | |
| 460 | |
| 461 EXPECT_EQ(&v11, changes[1].node); | |
| 462 EXPECT_EQ(&v12, changes[1].relative_node); | |
| 463 EXPECT_EQ(ORDER_DIRECTION_BELOW, changes[1].direction); | |
| 464 } | |
| 465 } | |
| 466 | |
| 467 namespace { | |
| 468 | |
| 469 typedef std::vector<std::string> Changes; | |
| 470 | |
| 471 std::string NodeIdToString(Id id) { | |
| 472 return (id == 0) ? "null" : | |
| 473 base::StringPrintf("%d,%d", HiWord(id), LoWord(id)); | |
| 474 } | |
| 475 | |
| 476 std::string RectToString(const gfx::Rect& rect) { | |
| 477 return base::StringPrintf("%d,%d %dx%d", | |
| 478 rect.x(), rect.y(), rect.width(), rect.height()); | |
| 479 } | |
| 480 | |
| 481 class BoundsChangeObserver : public NodeObserver { | |
| 482 public: | |
| 483 explicit BoundsChangeObserver(Node* node) : node_(node) { | |
| 484 node_->AddObserver(this); | |
| 485 } | |
| 486 virtual ~BoundsChangeObserver() { | |
| 487 node_->RemoveObserver(this); | |
| 488 } | |
| 489 | |
| 490 Changes GetAndClearChanges() { | |
| 491 Changes changes; | |
| 492 changes.swap(changes_); | |
| 493 return changes; | |
| 494 } | |
| 495 | |
| 496 private: | |
| 497 // Overridden from NodeObserver: | |
| 498 virtual void OnNodeBoundsChanging(Node* node, | |
| 499 const gfx::Rect& old_bounds, | |
| 500 const gfx::Rect& new_bounds) OVERRIDE { | |
| 501 changes_.push_back( | |
| 502 base::StringPrintf( | |
| 503 "node=%s old_bounds=%s new_bounds=%s phase=changing", | |
| 504 NodeIdToString(node->id()).c_str(), | |
| 505 RectToString(old_bounds).c_str(), | |
| 506 RectToString(new_bounds).c_str())); | |
| 507 } | |
| 508 virtual void OnNodeBoundsChanged(Node* node, | |
| 509 const gfx::Rect& old_bounds, | |
| 510 const gfx::Rect& new_bounds) OVERRIDE { | |
| 511 changes_.push_back( | |
| 512 base::StringPrintf( | |
| 513 "node=%s old_bounds=%s new_bounds=%s phase=changed", | |
| 514 NodeIdToString(node->id()).c_str(), | |
| 515 RectToString(old_bounds).c_str(), | |
| 516 RectToString(new_bounds).c_str())); | |
| 517 } | |
| 518 | |
| 519 Node* node_; | |
| 520 Changes changes_; | |
| 521 | |
| 522 DISALLOW_COPY_AND_ASSIGN(BoundsChangeObserver); | |
| 523 }; | |
| 524 | |
| 525 } // namespace | |
| 526 | |
| 527 TEST_F(NodeObserverTest, SetBounds) { | |
| 528 TestNode v1; | |
| 529 { | |
| 530 BoundsChangeObserver observer(&v1); | |
| 531 v1.SetBounds(gfx::Rect(0, 0, 100, 100)); | |
| 532 | |
| 533 Changes changes = observer.GetAndClearChanges(); | |
| 534 EXPECT_EQ(2U, changes.size()); | |
| 535 EXPECT_EQ( | |
| 536 "node=0,1 old_bounds=0,0 0x0 new_bounds=0,0 100x100 phase=changing", | |
| 537 changes[0]); | |
| 538 EXPECT_EQ( | |
| 539 "node=0,1 old_bounds=0,0 0x0 new_bounds=0,0 100x100 phase=changed", | |
| 540 changes[1]); | |
| 541 } | |
| 542 } | |
| 543 | |
| 544 } // namespace mojo | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 460863002:
Rename Node to View in the View Manager mojom & client lib. Service TBD. (Closed)
Base URL: svn://svn.chromium.org/chrome/trunk/src