| 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 "base/bind.h" | |
| 6 #include "base/logging.h" | |
| 7 #include "base/run_loop.h" | |
| 8 #include "components/mus/public/cpp/tests/view_manager_test_base.h" | |
| 9 #include "components/mus/public/cpp/util.h" | |
| 10 #include "components/mus/public/cpp/view_observer.h" | |
| 11 #include "components/mus/public/cpp/view_tree_connection.h" | |
| 12 #include "components/mus/public/cpp/view_tree_delegate.h" | |
| 13 #include "mojo/application/public/cpp/application_connection.h" | |
| 14 #include "mojo/application/public/cpp/application_impl.h" | |
| 15 #include "mojo/application/public/cpp/application_test_base.h" | |
| 16 #include "ui/mojo/geometry/geometry_util.h" | |
| 17 | |
| 18 namespace mus { | |
| 19 | |
| 20 namespace { | |
| 21 | |
| 22 class BoundsChangeObserver : public ViewObserver { | |
| 23 public: | |
| 24 explicit BoundsChangeObserver(View* view) : view_(view) { | |
| 25 view_->AddObserver(this); | |
| 26 } | |
| 27 ~BoundsChangeObserver() override { view_->RemoveObserver(this); } | |
| 28 | |
| 29 private: | |
| 30 // Overridden from ViewObserver: | |
| 31 void OnViewBoundsChanged(View* view, | |
| 32 const mojo::Rect& old_bounds, | |
| 33 const mojo::Rect& new_bounds) override { | |
| 34 DCHECK_EQ(view, view_); | |
| 35 EXPECT_TRUE(ViewManagerTestBase::QuitRunLoop()); | |
| 36 } | |
| 37 | |
| 38 View* view_; | |
| 39 | |
| 40 MOJO_DISALLOW_COPY_AND_ASSIGN(BoundsChangeObserver); | |
| 41 }; | |
| 42 | |
| 43 // Wait until the bounds of the supplied view change; returns false on timeout. | |
| 44 bool WaitForBoundsToChange(View* view) { | |
| 45 BoundsChangeObserver observer(view); | |
| 46 return ViewManagerTestBase::DoRunLoopWithTimeout(); | |
| 47 } | |
| 48 | |
| 49 // Spins a run loop until the tree beginning at |root| has |tree_size| views | |
| 50 // (including |root|). | |
| 51 class TreeSizeMatchesObserver : public ViewObserver { | |
| 52 public: | |
| 53 TreeSizeMatchesObserver(View* tree, size_t tree_size) | |
| 54 : tree_(tree), tree_size_(tree_size) { | |
| 55 tree_->AddObserver(this); | |
| 56 } | |
| 57 ~TreeSizeMatchesObserver() override { tree_->RemoveObserver(this); } | |
| 58 | |
| 59 bool IsTreeCorrectSize() { return CountViews(tree_) == tree_size_; } | |
| 60 | |
| 61 private: | |
| 62 // Overridden from ViewObserver: | |
| 63 void OnTreeChanged(const TreeChangeParams& params) override { | |
| 64 if (IsTreeCorrectSize()) | |
| 65 EXPECT_TRUE(ViewManagerTestBase::QuitRunLoop()); | |
| 66 } | |
| 67 | |
| 68 size_t CountViews(const View* view) const { | |
| 69 size_t count = 1; | |
| 70 View::Children::const_iterator it = view->children().begin(); | |
| 71 for (; it != view->children().end(); ++it) | |
| 72 count += CountViews(*it); | |
| 73 return count; | |
| 74 } | |
| 75 | |
| 76 View* tree_; | |
| 77 size_t tree_size_; | |
| 78 | |
| 79 MOJO_DISALLOW_COPY_AND_ASSIGN(TreeSizeMatchesObserver); | |
| 80 }; | |
| 81 | |
| 82 // Wait until |view| has |tree_size| descendants; returns false on timeout. The | |
| 83 // count includes |view|. For example, if you want to wait for |view| to have | |
| 84 // a single child, use a |tree_size| of 2. | |
| 85 bool WaitForTreeSizeToMatch(View* view, size_t tree_size) { | |
| 86 TreeSizeMatchesObserver observer(view, tree_size); | |
| 87 return observer.IsTreeCorrectSize() || | |
| 88 ViewManagerTestBase::DoRunLoopWithTimeout(); | |
| 89 } | |
| 90 | |
| 91 class OrderChangeObserver : public ViewObserver { | |
| 92 public: | |
| 93 OrderChangeObserver(View* view) : view_(view) { view_->AddObserver(this); } | |
| 94 ~OrderChangeObserver() override { view_->RemoveObserver(this); } | |
| 95 | |
| 96 private: | |
| 97 // Overridden from ViewObserver: | |
| 98 void OnViewReordered(View* view, | |
| 99 View* relative_view, | |
| 100 mojo::OrderDirection direction) override { | |
| 101 DCHECK_EQ(view, view_); | |
| 102 EXPECT_TRUE(ViewManagerTestBase::QuitRunLoop()); | |
| 103 } | |
| 104 | |
| 105 View* view_; | |
| 106 | |
| 107 MOJO_DISALLOW_COPY_AND_ASSIGN(OrderChangeObserver); | |
| 108 }; | |
| 109 | |
| 110 // Wait until |view|'s tree size matches |tree_size|; returns false on timeout. | |
| 111 bool WaitForOrderChange(ViewTreeConnection* connection, View* view) { | |
| 112 OrderChangeObserver observer(view); | |
| 113 return ViewManagerTestBase::DoRunLoopWithTimeout(); | |
| 114 } | |
| 115 | |
| 116 // Tracks a view's destruction. Query is_valid() for current state. | |
| 117 class ViewTracker : public ViewObserver { | |
| 118 public: | |
| 119 explicit ViewTracker(View* view) : view_(view) { view_->AddObserver(this); } | |
| 120 ~ViewTracker() override { | |
| 121 if (view_) | |
| 122 view_->RemoveObserver(this); | |
| 123 } | |
| 124 | |
| 125 bool is_valid() const { return !!view_; } | |
| 126 | |
| 127 private: | |
| 128 // Overridden from ViewObserver: | |
| 129 void OnViewDestroyed(View* view) override { | |
| 130 DCHECK_EQ(view, view_); | |
| 131 view_ = nullptr; | |
| 132 } | |
| 133 | |
| 134 View* view_; | |
| 135 | |
| 136 MOJO_DISALLOW_COPY_AND_ASSIGN(ViewTracker); | |
| 137 }; | |
| 138 | |
| 139 } // namespace | |
| 140 | |
| 141 // ViewManager ----------------------------------------------------------------- | |
| 142 | |
| 143 struct EmbedResult { | |
| 144 EmbedResult(ViewTreeConnection* connection, ConnectionSpecificId id) | |
| 145 : connection(connection), connection_id(id) {} | |
| 146 EmbedResult() : connection(nullptr), connection_id(0) {} | |
| 147 | |
| 148 ViewTreeConnection* connection; | |
| 149 | |
| 150 // The id supplied to the callback from OnEmbed(). Depending upon the | |
| 151 // access policy this may or may not match the connection id of | |
| 152 // |connection|. | |
| 153 ConnectionSpecificId connection_id; | |
| 154 }; | |
| 155 | |
| 156 // These tests model synchronization of two peer connections to the view manager | |
| 157 // service, that are given access to some root view. | |
| 158 | |
| 159 class ViewManagerTest : public ViewManagerTestBase { | |
| 160 public: | |
| 161 ViewManagerTest() {} | |
| 162 | |
| 163 // Embeds another version of the test app @ view. This runs a run loop until | |
| 164 // a response is received, or a timeout. On success the new ViewManager is | |
| 165 // returned. | |
| 166 EmbedResult Embed(View* view) { | |
| 167 return Embed(view, mojo::ViewTree::ACCESS_POLICY_DEFAULT); | |
| 168 } | |
| 169 | |
| 170 EmbedResult Embed(View* view, uint32_t access_policy_bitmask) { | |
| 171 DCHECK(!embed_details_); | |
| 172 embed_details_.reset(new EmbedDetails); | |
| 173 view->Embed(ConnectToApplicationAndGetViewManagerClient(), | |
| 174 access_policy_bitmask, | |
| 175 base::Bind(&ViewManagerTest::EmbedCallbackImpl, | |
| 176 base::Unretained(this))); | |
| 177 embed_details_->waiting = true; | |
| 178 if (!ViewManagerTestBase::DoRunLoopWithTimeout()) | |
| 179 return EmbedResult(); | |
| 180 const EmbedResult result(embed_details_->connection, | |
| 181 embed_details_->connection_id); | |
| 182 embed_details_.reset(); | |
| 183 return result; | |
| 184 } | |
| 185 | |
| 186 // Establishes a connection to this application and asks for a | |
| 187 // ViewTreeClient. | |
| 188 mojo::ViewTreeClientPtr ConnectToApplicationAndGetViewManagerClient() { | |
| 189 mojo::URLRequestPtr request(mojo::URLRequest::New()); | |
| 190 request->url = mojo::String::From(application_impl()->url()); | |
| 191 scoped_ptr<mojo::ApplicationConnection> connection = | |
| 192 application_impl()->ConnectToApplication(request.Pass()); | |
| 193 mojo::ViewTreeClientPtr client; | |
| 194 connection->ConnectToService(&client); | |
| 195 return client.Pass(); | |
| 196 } | |
| 197 | |
| 198 // ViewManagerTestBase: | |
| 199 void OnEmbed(View* root) override { | |
| 200 if (!embed_details_) { | |
| 201 ViewManagerTestBase::OnEmbed(root); | |
| 202 return; | |
| 203 } | |
| 204 | |
| 205 embed_details_->connection = root->connection(); | |
| 206 if (embed_details_->callback_run) | |
| 207 EXPECT_TRUE(ViewManagerTestBase::QuitRunLoop()); | |
| 208 } | |
| 209 | |
| 210 private: | |
| 211 // Used to track the state of a call to view->Embed(). | |
| 212 struct EmbedDetails { | |
| 213 EmbedDetails() | |
| 214 : callback_run(false), | |
| 215 result(false), | |
| 216 waiting(false), | |
| 217 connection_id(0), | |
| 218 connection(nullptr) {} | |
| 219 | |
| 220 // The callback supplied to Embed() was received. | |
| 221 bool callback_run; | |
| 222 | |
| 223 // The boolean supplied to the Embed() callback. | |
| 224 bool result; | |
| 225 | |
| 226 // Whether a MessageLoop is running. | |
| 227 bool waiting; | |
| 228 | |
| 229 // Connection id supplied to the Embed() callback. | |
| 230 ConnectionSpecificId connection_id; | |
| 231 | |
| 232 // The ViewTreeConnection that resulted from the Embed(). null if |result| | |
| 233 // is false. | |
| 234 ViewTreeConnection* connection; | |
| 235 }; | |
| 236 | |
| 237 void EmbedCallbackImpl(bool result, ConnectionSpecificId connection_id) { | |
| 238 embed_details_->callback_run = true; | |
| 239 embed_details_->result = result; | |
| 240 embed_details_->connection_id = connection_id; | |
| 241 if (embed_details_->waiting && (!result || embed_details_->connection)) | |
| 242 EXPECT_TRUE(ViewManagerTestBase::QuitRunLoop()); | |
| 243 } | |
| 244 | |
| 245 scoped_ptr<EmbedDetails> embed_details_; | |
| 246 | |
| 247 MOJO_DISALLOW_COPY_AND_ASSIGN(ViewManagerTest); | |
| 248 }; | |
| 249 | |
| 250 TEST_F(ViewManagerTest, RootView) { | |
| 251 ASSERT_NE(nullptr, window_manager()); | |
| 252 EXPECT_NE(nullptr, window_manager()->GetRoot()); | |
| 253 } | |
| 254 | |
| 255 TEST_F(ViewManagerTest, Embed) { | |
| 256 View* view = window_manager()->CreateView(); | |
| 257 ASSERT_NE(nullptr, view); | |
| 258 view->SetVisible(true); | |
| 259 window_manager()->GetRoot()->AddChild(view); | |
| 260 ViewTreeConnection* embedded = Embed(view).connection; | |
| 261 ASSERT_NE(nullptr, embedded); | |
| 262 | |
| 263 View* view_in_embedded = embedded->GetRoot(); | |
| 264 ASSERT_NE(nullptr, view_in_embedded); | |
| 265 EXPECT_EQ(view->id(), view_in_embedded->id()); | |
| 266 EXPECT_EQ(nullptr, view_in_embedded->parent()); | |
| 267 EXPECT_TRUE(view_in_embedded->children().empty()); | |
| 268 } | |
| 269 | |
| 270 // Window manager has two views, N1 and N11. Embeds A at N1. A should not see | |
| 271 // N11. | |
| 272 TEST_F(ViewManagerTest, EmbeddedDoesntSeeChild) { | |
| 273 View* view = window_manager()->CreateView(); | |
| 274 ASSERT_NE(nullptr, view); | |
| 275 view->SetVisible(true); | |
| 276 window_manager()->GetRoot()->AddChild(view); | |
| 277 View* nested = window_manager()->CreateView(); | |
| 278 ASSERT_NE(nullptr, nested); | |
| 279 nested->SetVisible(true); | |
| 280 view->AddChild(nested); | |
| 281 | |
| 282 ViewTreeConnection* embedded = Embed(view).connection; | |
| 283 ASSERT_NE(nullptr, embedded); | |
| 284 View* view_in_embedded = embedded->GetRoot(); | |
| 285 EXPECT_EQ(view->id(), view_in_embedded->id()); | |
| 286 EXPECT_EQ(nullptr, view_in_embedded->parent()); | |
| 287 EXPECT_TRUE(view_in_embedded->children().empty()); | |
| 288 } | |
| 289 | |
| 290 // TODO(beng): write a replacement test for the one that once existed here: | |
| 291 // This test validates the following scenario: | |
| 292 // - a view originating from one connection | |
| 293 // - a view originating from a second connection | |
| 294 // + the connection originating the view is destroyed | |
| 295 // -> the view should still exist (since the second connection is live) but | |
| 296 // should be disconnected from any views. | |
| 297 // http://crbug.com/396300 | |
| 298 // | |
| 299 // TODO(beng): The new test should validate the scenario as described above | |
| 300 // except that the second connection still has a valid tree. | |
| 301 | |
| 302 // Verifies that bounds changes applied to a view hierarchy in one connection | |
| 303 // are reflected to another. | |
| 304 TEST_F(ViewManagerTest, SetBounds) { | |
| 305 View* view = window_manager()->CreateView(); | |
| 306 view->SetVisible(true); | |
| 307 window_manager()->GetRoot()->AddChild(view); | |
| 308 ViewTreeConnection* embedded = Embed(view).connection; | |
| 309 ASSERT_NE(nullptr, embedded); | |
| 310 | |
| 311 View* view_in_embedded = embedded->GetViewById(view->id()); | |
| 312 EXPECT_EQ(view->bounds(), view_in_embedded->bounds()); | |
| 313 | |
| 314 mojo::Rect rect; | |
| 315 rect.width = rect.height = 100; | |
| 316 view->SetBounds(rect); | |
| 317 ASSERT_TRUE(WaitForBoundsToChange(view_in_embedded)); | |
| 318 EXPECT_EQ(view->bounds(), view_in_embedded->bounds()); | |
| 319 } | |
| 320 | |
| 321 // Verifies that bounds changes applied to a view owned by a different | |
| 322 // connection are refused. | |
| 323 TEST_F(ViewManagerTest, SetBoundsSecurity) { | |
| 324 View* view = window_manager()->CreateView(); | |
| 325 view->SetVisible(true); | |
| 326 window_manager()->GetRoot()->AddChild(view); | |
| 327 ViewTreeConnection* embedded = Embed(view).connection; | |
| 328 ASSERT_NE(nullptr, embedded); | |
| 329 | |
| 330 View* view_in_embedded = embedded->GetViewById(view->id()); | |
| 331 mojo::Rect rect; | |
| 332 rect.width = 800; | |
| 333 rect.height = 600; | |
| 334 view->SetBounds(rect); | |
| 335 ASSERT_TRUE(WaitForBoundsToChange(view_in_embedded)); | |
| 336 | |
| 337 rect.width = 1024; | |
| 338 rect.height = 768; | |
| 339 view_in_embedded->SetBounds(rect); | |
| 340 // Bounds change should have been rejected. | |
| 341 EXPECT_EQ(view->bounds(), view_in_embedded->bounds()); | |
| 342 } | |
| 343 | |
| 344 // Verifies that a view can only be destroyed by the connection that created it. | |
| 345 TEST_F(ViewManagerTest, DestroySecurity) { | |
| 346 View* view = window_manager()->CreateView(); | |
| 347 view->SetVisible(true); | |
| 348 window_manager()->GetRoot()->AddChild(view); | |
| 349 ViewTreeConnection* embedded = Embed(view).connection; | |
| 350 ASSERT_NE(nullptr, embedded); | |
| 351 | |
| 352 View* view_in_embedded = embedded->GetViewById(view->id()); | |
| 353 | |
| 354 ViewTracker tracker2(view_in_embedded); | |
| 355 view_in_embedded->Destroy(); | |
| 356 // View should not have been destroyed. | |
| 357 EXPECT_TRUE(tracker2.is_valid()); | |
| 358 | |
| 359 ViewTracker tracker1(view); | |
| 360 view->Destroy(); | |
| 361 EXPECT_FALSE(tracker1.is_valid()); | |
| 362 } | |
| 363 | |
| 364 TEST_F(ViewManagerTest, MultiRoots) { | |
| 365 View* view1 = window_manager()->CreateView(); | |
| 366 view1->SetVisible(true); | |
| 367 window_manager()->GetRoot()->AddChild(view1); | |
| 368 View* view2 = window_manager()->CreateView(); | |
| 369 view2->SetVisible(true); | |
| 370 window_manager()->GetRoot()->AddChild(view2); | |
| 371 ViewTreeConnection* embedded1 = Embed(view1).connection; | |
| 372 ASSERT_NE(nullptr, embedded1); | |
| 373 ViewTreeConnection* embedded2 = Embed(view2).connection; | |
| 374 ASSERT_NE(nullptr, embedded2); | |
| 375 EXPECT_NE(embedded1, embedded2); | |
| 376 } | |
| 377 | |
| 378 // TODO(alhaad): Currently, the RunLoop gets stuck waiting for order change. | |
| 379 // Debug and re-enable this. | |
| 380 TEST_F(ViewManagerTest, DISABLED_Reorder) { | |
| 381 View* view1 = window_manager()->CreateView(); | |
| 382 view1->SetVisible(true); | |
| 383 window_manager()->GetRoot()->AddChild(view1); | |
| 384 | |
| 385 ViewTreeConnection* embedded = Embed(view1).connection; | |
| 386 ASSERT_NE(nullptr, embedded); | |
| 387 | |
| 388 View* view11 = embedded->CreateView(); | |
| 389 view11->SetVisible(true); | |
| 390 embedded->GetRoot()->AddChild(view11); | |
| 391 View* view12 = embedded->CreateView(); | |
| 392 view12->SetVisible(true); | |
| 393 embedded->GetRoot()->AddChild(view12); | |
| 394 | |
| 395 View* root_in_embedded = embedded->GetRoot(); | |
| 396 | |
| 397 { | |
| 398 ASSERT_TRUE(WaitForTreeSizeToMatch(root_in_embedded, 3u)); | |
| 399 view11->MoveToFront(); | |
| 400 ASSERT_TRUE(WaitForOrderChange(embedded, root_in_embedded)); | |
| 401 | |
| 402 EXPECT_EQ(root_in_embedded->children().front(), | |
| 403 embedded->GetViewById(view12->id())); | |
| 404 EXPECT_EQ(root_in_embedded->children().back(), | |
| 405 embedded->GetViewById(view11->id())); | |
| 406 } | |
| 407 | |
| 408 { | |
| 409 view11->MoveToBack(); | |
| 410 ASSERT_TRUE( | |
| 411 WaitForOrderChange(embedded, embedded->GetViewById(view11->id()))); | |
| 412 | |
| 413 EXPECT_EQ(root_in_embedded->children().front(), | |
| 414 embedded->GetViewById(view11->id())); | |
| 415 EXPECT_EQ(root_in_embedded->children().back(), | |
| 416 embedded->GetViewById(view12->id())); | |
| 417 } | |
| 418 } | |
| 419 | |
| 420 namespace { | |
| 421 | |
| 422 class VisibilityChangeObserver : public ViewObserver { | |
| 423 public: | |
| 424 explicit VisibilityChangeObserver(View* view) : view_(view) { | |
| 425 view_->AddObserver(this); | |
| 426 } | |
| 427 ~VisibilityChangeObserver() override { view_->RemoveObserver(this); } | |
| 428 | |
| 429 private: | |
| 430 // Overridden from ViewObserver: | |
| 431 void OnViewVisibilityChanged(View* view) override { | |
| 432 EXPECT_EQ(view, view_); | |
| 433 EXPECT_TRUE(ViewManagerTestBase::QuitRunLoop()); | |
| 434 } | |
| 435 | |
| 436 View* view_; | |
| 437 | |
| 438 MOJO_DISALLOW_COPY_AND_ASSIGN(VisibilityChangeObserver); | |
| 439 }; | |
| 440 | |
| 441 } // namespace | |
| 442 | |
| 443 TEST_F(ViewManagerTest, Visible) { | |
| 444 View* view1 = window_manager()->CreateView(); | |
| 445 view1->SetVisible(true); | |
| 446 window_manager()->GetRoot()->AddChild(view1); | |
| 447 | |
| 448 // Embed another app and verify initial state. | |
| 449 ViewTreeConnection* embedded = Embed(view1).connection; | |
| 450 ASSERT_NE(nullptr, embedded); | |
| 451 ASSERT_NE(nullptr, embedded->GetRoot()); | |
| 452 View* embedded_root = embedded->GetRoot(); | |
| 453 EXPECT_TRUE(embedded_root->visible()); | |
| 454 EXPECT_TRUE(embedded_root->IsDrawn()); | |
| 455 | |
| 456 // Change the visible state from the first connection and verify its mirrored | |
| 457 // correctly to the embedded app. | |
| 458 { | |
| 459 VisibilityChangeObserver observer(embedded_root); | |
| 460 view1->SetVisible(false); | |
| 461 ASSERT_TRUE(ViewManagerTestBase::DoRunLoopWithTimeout()); | |
| 462 } | |
| 463 | |
| 464 EXPECT_FALSE(view1->visible()); | |
| 465 EXPECT_FALSE(view1->IsDrawn()); | |
| 466 | |
| 467 EXPECT_FALSE(embedded_root->visible()); | |
| 468 EXPECT_FALSE(embedded_root->IsDrawn()); | |
| 469 | |
| 470 // Make the node visible again. | |
| 471 { | |
| 472 VisibilityChangeObserver observer(embedded_root); | |
| 473 view1->SetVisible(true); | |
| 474 ASSERT_TRUE(ViewManagerTestBase::DoRunLoopWithTimeout()); | |
| 475 } | |
| 476 | |
| 477 EXPECT_TRUE(view1->visible()); | |
| 478 EXPECT_TRUE(view1->IsDrawn()); | |
| 479 | |
| 480 EXPECT_TRUE(embedded_root->visible()); | |
| 481 EXPECT_TRUE(embedded_root->IsDrawn()); | |
| 482 } | |
| 483 | |
| 484 namespace { | |
| 485 | |
| 486 class DrawnChangeObserver : public ViewObserver { | |
| 487 public: | |
| 488 explicit DrawnChangeObserver(View* view) : view_(view) { | |
| 489 view_->AddObserver(this); | |
| 490 } | |
| 491 ~DrawnChangeObserver() override { view_->RemoveObserver(this); } | |
| 492 | |
| 493 private: | |
| 494 // Overridden from ViewObserver: | |
| 495 void OnViewDrawnChanged(View* view) override { | |
| 496 EXPECT_EQ(view, view_); | |
| 497 EXPECT_TRUE(ViewManagerTestBase::QuitRunLoop()); | |
| 498 } | |
| 499 | |
| 500 View* view_; | |
| 501 | |
| 502 MOJO_DISALLOW_COPY_AND_ASSIGN(DrawnChangeObserver); | |
| 503 }; | |
| 504 | |
| 505 } // namespace | |
| 506 | |
| 507 TEST_F(ViewManagerTest, Drawn) { | |
| 508 View* view1 = window_manager()->CreateView(); | |
| 509 view1->SetVisible(true); | |
| 510 window_manager()->GetRoot()->AddChild(view1); | |
| 511 | |
| 512 // Embed another app and verify initial state. | |
| 513 ViewTreeConnection* embedded = Embed(view1).connection; | |
| 514 ASSERT_NE(nullptr, embedded); | |
| 515 ASSERT_NE(nullptr, embedded->GetRoot()); | |
| 516 View* embedded_root = embedded->GetRoot(); | |
| 517 EXPECT_TRUE(embedded_root->visible()); | |
| 518 EXPECT_TRUE(embedded_root->IsDrawn()); | |
| 519 | |
| 520 // Change the visibility of the root, this should propagate a drawn state | |
| 521 // change to |embedded|. | |
| 522 { | |
| 523 DrawnChangeObserver observer(embedded_root); | |
| 524 window_manager()->GetRoot()->SetVisible(false); | |
| 525 ASSERT_TRUE(DoRunLoopWithTimeout()); | |
| 526 } | |
| 527 | |
| 528 EXPECT_TRUE(view1->visible()); | |
| 529 EXPECT_FALSE(view1->IsDrawn()); | |
| 530 | |
| 531 EXPECT_TRUE(embedded_root->visible()); | |
| 532 EXPECT_FALSE(embedded_root->IsDrawn()); | |
| 533 } | |
| 534 | |
| 535 // TODO(beng): tests for view event dispatcher. | |
| 536 // - verify that we see events for all views. | |
| 537 | |
| 538 namespace { | |
| 539 | |
| 540 class FocusChangeObserver : public ViewObserver { | |
| 541 public: | |
| 542 explicit FocusChangeObserver(View* view) | |
| 543 : view_(view), last_gained_focus_(nullptr), last_lost_focus_(nullptr) { | |
| 544 view_->AddObserver(this); | |
| 545 } | |
| 546 ~FocusChangeObserver() override { view_->RemoveObserver(this); } | |
| 547 | |
| 548 View* last_gained_focus() { return last_gained_focus_; } | |
| 549 | |
| 550 View* last_lost_focus() { return last_lost_focus_; } | |
| 551 | |
| 552 private: | |
| 553 // Overridden from ViewObserver. | |
| 554 void OnViewFocusChanged(View* gained_focus, View* lost_focus) override { | |
| 555 EXPECT_TRUE(!gained_focus || gained_focus->HasFocus()); | |
| 556 EXPECT_FALSE(lost_focus && lost_focus->HasFocus()); | |
| 557 last_gained_focus_ = gained_focus; | |
| 558 last_lost_focus_ = lost_focus; | |
| 559 EXPECT_TRUE(ViewManagerTestBase::QuitRunLoop()); | |
| 560 } | |
| 561 | |
| 562 View* view_; | |
| 563 View* last_gained_focus_; | |
| 564 View* last_lost_focus_; | |
| 565 | |
| 566 MOJO_DISALLOW_COPY_AND_ASSIGN(FocusChangeObserver); | |
| 567 }; | |
| 568 | |
| 569 } // namespace | |
| 570 | |
| 571 TEST_F(ViewManagerTest, Focus) { | |
| 572 View* view1 = window_manager()->CreateView(); | |
| 573 view1->SetVisible(true); | |
| 574 window_manager()->GetRoot()->AddChild(view1); | |
| 575 | |
| 576 ViewTreeConnection* embedded = Embed(view1).connection; | |
| 577 ASSERT_NE(nullptr, embedded); | |
| 578 View* view11 = embedded->CreateView(); | |
| 579 view11->SetVisible(true); | |
| 580 embedded->GetRoot()->AddChild(view11); | |
| 581 | |
| 582 // TODO(alhaad): Figure out why switching focus between views from different | |
| 583 // connections is causing the tests to crash and add tests for that. | |
| 584 { | |
| 585 View* embedded_root = embedded->GetRoot(); | |
| 586 FocusChangeObserver observer(embedded_root); | |
| 587 embedded_root->SetFocus(); | |
| 588 ASSERT_TRUE(DoRunLoopWithTimeout()); | |
| 589 ASSERT_NE(nullptr, observer.last_gained_focus()); | |
| 590 EXPECT_EQ(embedded_root->id(), observer.last_gained_focus()->id()); | |
| 591 } | |
| 592 { | |
| 593 FocusChangeObserver observer(view11); | |
| 594 view11->SetFocus(); | |
| 595 ASSERT_TRUE(DoRunLoopWithTimeout()); | |
| 596 ASSERT_NE(nullptr, observer.last_gained_focus()); | |
| 597 ASSERT_NE(nullptr, observer.last_lost_focus()); | |
| 598 EXPECT_EQ(view11->id(), observer.last_gained_focus()->id()); | |
| 599 EXPECT_EQ(embedded->GetRoot()->id(), observer.last_lost_focus()->id()); | |
| 600 } | |
| 601 { | |
| 602 // Add an observer on the View that loses focus, and make sure the observer | |
| 603 // sees the right values. | |
| 604 FocusChangeObserver observer(view11); | |
| 605 embedded->GetRoot()->SetFocus(); | |
| 606 ASSERT_TRUE(DoRunLoopWithTimeout()); | |
| 607 ASSERT_NE(nullptr, observer.last_gained_focus()); | |
| 608 ASSERT_NE(nullptr, observer.last_lost_focus()); | |
| 609 EXPECT_EQ(view11->id(), observer.last_lost_focus()->id()); | |
| 610 EXPECT_EQ(embedded->GetRoot()->id(), observer.last_gained_focus()->id()); | |
| 611 } | |
| 612 } | |
| 613 | |
| 614 namespace { | |
| 615 | |
| 616 class DestroyedChangedObserver : public ViewObserver { | |
| 617 public: | |
| 618 DestroyedChangedObserver(ViewManagerTestBase* test, | |
| 619 View* view, | |
| 620 bool* got_destroy) | |
| 621 : test_(test), view_(view), got_destroy_(got_destroy) { | |
| 622 view_->AddObserver(this); | |
| 623 } | |
| 624 ~DestroyedChangedObserver() override { | |
| 625 if (view_) | |
| 626 view_->RemoveObserver(this); | |
| 627 } | |
| 628 | |
| 629 private: | |
| 630 // Overridden from ViewObserver: | |
| 631 void OnViewDestroyed(View* view) override { | |
| 632 EXPECT_EQ(view, view_); | |
| 633 view_->RemoveObserver(this); | |
| 634 *got_destroy_ = true; | |
| 635 view_ = nullptr; | |
| 636 | |
| 637 // We should always get OnViewDestroyed() before OnConnectionLost(). | |
| 638 EXPECT_FALSE(test_->view_tree_connection_destroyed()); | |
| 639 } | |
| 640 | |
| 641 ViewManagerTestBase* test_; | |
| 642 View* view_; | |
| 643 bool* got_destroy_; | |
| 644 | |
| 645 MOJO_DISALLOW_COPY_AND_ASSIGN(DestroyedChangedObserver); | |
| 646 }; | |
| 647 | |
| 648 } // namespace | |
| 649 | |
| 650 // Verifies deleting a ViewManager sends the right notifications. | |
| 651 TEST_F(ViewManagerTest, DeleteViewManager) { | |
| 652 View* view = window_manager()->CreateView(); | |
| 653 ASSERT_NE(nullptr, view); | |
| 654 view->SetVisible(true); | |
| 655 window_manager()->GetRoot()->AddChild(view); | |
| 656 ViewTreeConnection* connection = Embed(view).connection; | |
| 657 ASSERT_TRUE(connection); | |
| 658 bool got_destroy = false; | |
| 659 DestroyedChangedObserver observer(this, connection->GetRoot(), &got_destroy); | |
| 660 delete connection; | |
| 661 EXPECT_TRUE(view_tree_connection_destroyed()); | |
| 662 EXPECT_TRUE(got_destroy); | |
| 663 } | |
| 664 | |
| 665 // Verifies two Embed()s in the same view trigger deletion of the first | |
| 666 // ViewManager. | |
| 667 TEST_F(ViewManagerTest, DisconnectTriggersDelete) { | |
| 668 View* view = window_manager()->CreateView(); | |
| 669 ASSERT_NE(nullptr, view); | |
| 670 view->SetVisible(true); | |
| 671 window_manager()->GetRoot()->AddChild(view); | |
| 672 ViewTreeConnection* connection = Embed(view).connection; | |
| 673 EXPECT_NE(connection, window_manager()); | |
| 674 View* embedded_view = connection->CreateView(); | |
| 675 // Embed again, this should trigger disconnect and deletion of connection. | |
| 676 bool got_destroy; | |
| 677 DestroyedChangedObserver observer(this, embedded_view, &got_destroy); | |
| 678 EXPECT_FALSE(view_tree_connection_destroyed()); | |
| 679 Embed(view); | |
| 680 EXPECT_TRUE(view_tree_connection_destroyed()); | |
| 681 } | |
| 682 | |
| 683 class ViewRemovedFromParentObserver : public ViewObserver { | |
| 684 public: | |
| 685 explicit ViewRemovedFromParentObserver(View* view) | |
| 686 : view_(view), was_removed_(false) { | |
| 687 view_->AddObserver(this); | |
| 688 } | |
| 689 ~ViewRemovedFromParentObserver() override { view_->RemoveObserver(this); } | |
| 690 | |
| 691 bool was_removed() const { return was_removed_; } | |
| 692 | |
| 693 private: | |
| 694 // Overridden from ViewObserver: | |
| 695 void OnTreeChanged(const TreeChangeParams& params) override { | |
| 696 if (params.target == view_ && !params.new_parent) | |
| 697 was_removed_ = true; | |
| 698 } | |
| 699 | |
| 700 View* view_; | |
| 701 bool was_removed_; | |
| 702 | |
| 703 MOJO_DISALLOW_COPY_AND_ASSIGN(ViewRemovedFromParentObserver); | |
| 704 }; | |
| 705 | |
| 706 TEST_F(ViewManagerTest, EmbedRemovesChildren) { | |
| 707 View* view1 = window_manager()->CreateView(); | |
| 708 View* view2 = window_manager()->CreateView(); | |
| 709 window_manager()->GetRoot()->AddChild(view1); | |
| 710 view1->AddChild(view2); | |
| 711 | |
| 712 ViewRemovedFromParentObserver observer(view2); | |
| 713 view1->Embed(ConnectToApplicationAndGetViewManagerClient()); | |
| 714 EXPECT_TRUE(observer.was_removed()); | |
| 715 EXPECT_EQ(nullptr, view2->parent()); | |
| 716 EXPECT_TRUE(view1->children().empty()); | |
| 717 | |
| 718 // Run the message loop so the Embed() call above completes. Without this | |
| 719 // we may end up reconnecting to the test and rerunning the test, which is | |
| 720 // problematic since the other services don't shut down. | |
| 721 ASSERT_TRUE(DoRunLoopWithTimeout()); | |
| 722 } | |
| 723 | |
| 724 namespace { | |
| 725 | |
| 726 class DestroyObserver : public ViewObserver { | |
| 727 public: | |
| 728 DestroyObserver(ViewManagerTestBase* test, | |
| 729 ViewTreeConnection* connection, | |
| 730 bool* got_destroy) | |
| 731 : test_(test), got_destroy_(got_destroy) { | |
| 732 connection->GetRoot()->AddObserver(this); | |
| 733 } | |
| 734 ~DestroyObserver() override {} | |
| 735 | |
| 736 private: | |
| 737 // Overridden from ViewObserver: | |
| 738 void OnViewDestroyed(View* view) override { | |
| 739 *got_destroy_ = true; | |
| 740 view->RemoveObserver(this); | |
| 741 | |
| 742 // We should always get OnViewDestroyed() before OnViewManagerDestroyed(). | |
| 743 EXPECT_FALSE(test_->view_tree_connection_destroyed()); | |
| 744 | |
| 745 EXPECT_TRUE(ViewManagerTestBase::QuitRunLoop()); | |
| 746 } | |
| 747 | |
| 748 ViewManagerTestBase* test_; | |
| 749 bool* got_destroy_; | |
| 750 | |
| 751 MOJO_DISALLOW_COPY_AND_ASSIGN(DestroyObserver); | |
| 752 }; | |
| 753 | |
| 754 } // namespace | |
| 755 | |
| 756 // Verifies deleting a View that is the root of another connection notifies | |
| 757 // observers in the right order (OnViewDestroyed() before | |
| 758 // OnViewManagerDestroyed()). | |
| 759 TEST_F(ViewManagerTest, ViewManagerDestroyedAfterRootObserver) { | |
| 760 View* embed_view = window_manager()->CreateView(); | |
| 761 window_manager()->GetRoot()->AddChild(embed_view); | |
| 762 | |
| 763 ViewTreeConnection* embedded_connection = Embed(embed_view).connection; | |
| 764 | |
| 765 bool got_destroy = false; | |
| 766 DestroyObserver observer(this, embedded_connection, &got_destroy); | |
| 767 // Delete the view |embedded_connection| is embedded in. This is async, | |
| 768 // but will eventually trigger deleting |embedded_connection|. | |
| 769 embed_view->Destroy(); | |
| 770 EXPECT_TRUE(DoRunLoopWithTimeout()); | |
| 771 EXPECT_TRUE(got_destroy); | |
| 772 } | |
| 773 | |
| 774 // Verifies an embed root sees views created beneath it from another | |
| 775 // connection. | |
| 776 TEST_F(ViewManagerTest, EmbedRootSeesHierarchyChanged) { | |
| 777 View* embed_view = window_manager()->CreateView(); | |
| 778 window_manager()->GetRoot()->AddChild(embed_view); | |
| 779 | |
| 780 ViewTreeConnection* vm2 = | |
| 781 Embed(embed_view, mojo::ViewTree::ACCESS_POLICY_EMBED_ROOT).connection; | |
| 782 View* vm2_v1 = vm2->CreateView(); | |
| 783 vm2->GetRoot()->AddChild(vm2_v1); | |
| 784 | |
| 785 ViewTreeConnection* vm3 = Embed(vm2_v1).connection; | |
| 786 View* vm3_v1 = vm3->CreateView(); | |
| 787 vm3->GetRoot()->AddChild(vm3_v1); | |
| 788 | |
| 789 // As |vm2| is an embed root it should get notified about |vm3_v1|. | |
| 790 ASSERT_TRUE(WaitForTreeSizeToMatch(vm2_v1, 2)); | |
| 791 } | |
| 792 | |
| 793 TEST_F(ViewManagerTest, EmbedFromEmbedRoot) { | |
| 794 View* embed_view = window_manager()->CreateView(); | |
| 795 window_manager()->GetRoot()->AddChild(embed_view); | |
| 796 | |
| 797 // Give the connection embedded at |embed_view| embed root powers. | |
| 798 const EmbedResult result1 = | |
| 799 Embed(embed_view, mojo::ViewTree::ACCESS_POLICY_EMBED_ROOT); | |
| 800 ViewTreeConnection* vm2 = result1.connection; | |
| 801 EXPECT_EQ(result1.connection_id, vm2->GetConnectionId()); | |
| 802 View* vm2_v1 = vm2->CreateView(); | |
| 803 vm2->GetRoot()->AddChild(vm2_v1); | |
| 804 | |
| 805 const EmbedResult result2 = Embed(vm2_v1); | |
| 806 ViewTreeConnection* vm3 = result2.connection; | |
| 807 EXPECT_EQ(result2.connection_id, vm3->GetConnectionId()); | |
| 808 View* vm3_v1 = vm3->CreateView(); | |
| 809 vm3->GetRoot()->AddChild(vm3_v1); | |
| 810 | |
| 811 // Embed from v3, the callback should not get the connection id as vm3 is not | |
| 812 // an embed root. | |
| 813 const EmbedResult result3 = Embed(vm3_v1); | |
| 814 ASSERT_TRUE(result3.connection); | |
| 815 EXPECT_EQ(0, result3.connection_id); | |
| 816 | |
| 817 // As |vm2| is an embed root it should get notified about |vm3_v1|. | |
| 818 ASSERT_TRUE(WaitForTreeSizeToMatch(vm2_v1, 2)); | |
| 819 | |
| 820 // Embed() from vm2 in vm3_v1. This is allowed as vm2 is an embed root, and | |
| 821 // further the callback should see the connection id. | |
| 822 ASSERT_EQ(1u, vm2_v1->children().size()); | |
| 823 View* vm3_v1_in_vm2 = vm2_v1->children()[0]; | |
| 824 const EmbedResult result4 = Embed(vm3_v1_in_vm2); | |
| 825 ASSERT_TRUE(result4.connection); | |
| 826 EXPECT_EQ(result4.connection_id, result4.connection->GetConnectionId()); | |
| 827 } | |
| 828 | |
| 829 } // namespace mus | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 1377493002:
mus: move View Manager to components/mus/vm (Closed)
Base URL: https://chromium.googlesource.com/chromium/src.git@master