components/view_manager/view_manager_client_apptest.cc

   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 "components/view_manager/public/cpp/view_manager.h"
   6
   7 #include "base/bind.h"
   8 #include "base/location.h"
   9 #include "base/logging.h"
  10 #include "base/memory/scoped_vector.h"
  11 #include "base/message_loop/message_loop.h"
  12 #include "base/run_loop.h"
  13 #include "base/test/test_timeouts.h"
  14 #include "components/view_manager/public/cpp/lib/view_manager_client_impl.h"
  15 #include "components/view_manager/public/cpp/view_manager_client_factory.h"
  16 #include "components/view_manager/public/cpp/view_manager_delegate.h"
  17 #include "components/view_manager/public/cpp/view_manager_init.h"
  18 #include "components/view_manager/public/cpp/view_observer.h"
  19 #include "mojo/application/application_test_base_chromium.h"
  20 #include "mojo/application/public/cpp/application_connection.h"
  21 #include "mojo/application/public/cpp/application_delegate.h"
  22 #include "mojo/application/public/cpp/application_impl.h"
  23 #include "mojo/application/public/cpp/service_provider_impl.h"
  24 #include "ui/mojo/geometry/geometry_util.h"
  25
  26 namespace mojo {
  27
  28 namespace {
  29
  30 base::RunLoop* current_run_loop = nullptr;
  31
  32 void TimeoutRunLoop(const base::Closure& timeout_task, bool* timeout) {
  33   CHECK(current_run_loop);
  34   *timeout = true;
  35   timeout_task.Run();
  36 }
  37
  38 bool DoRunLoopWithTimeout() {
  39   if (current_run_loop != nullptr)
  40     return false;
  41
  42   bool timeout = false;
  43   base::RunLoop run_loop;
  44   base::MessageLoop::current()->PostDelayedTask(
  45       FROM_HERE, base::Bind(&TimeoutRunLoop, run_loop.QuitClosure(), &timeout),
  46       TestTimeouts::action_timeout());
  47
  48   current_run_loop = &run_loop;
  49   current_run_loop->Run();
  50   current_run_loop = nullptr;
  51   return !timeout;
  52 }
  53
  54 void QuitRunLoop() {
  55   current_run_loop->Quit();
  56   current_run_loop = nullptr;
  57 }
  58
  59 class BoundsChangeObserver : public ViewObserver {
  60  public:
  61   explicit BoundsChangeObserver(View* view) : view_(view) {
  62     view_->AddObserver(this);
  63   }
  64   ~BoundsChangeObserver() override { view_->RemoveObserver(this); }
  65
  66  private:
  67   // Overridden from ViewObserver:
  68   void OnViewBoundsChanged(View* view,
  69                            const Rect& old_bounds,
  70                            const Rect& new_bounds) override {
  71     DCHECK_EQ(view, view_);
  72     QuitRunLoop();
  73   }
  74
  75   View* view_;
  76
  77   MOJO_DISALLOW_COPY_AND_ASSIGN(BoundsChangeObserver);
  78 };
  79
  80 // Wait until the bounds of the supplied view change; returns false on timeout.
  81 bool WaitForBoundsToChange(View* view) {
  82   BoundsChangeObserver observer(view);
  83   return DoRunLoopWithTimeout();
  84 }
  85
  86 // Spins a run loop until the tree beginning at |root| has |tree_size| views
  87 // (including |root|).
  88 class TreeSizeMatchesObserver : public ViewObserver {
  89  public:
  90   TreeSizeMatchesObserver(View* tree, size_t tree_size)
  91       : tree_(tree), tree_size_(tree_size) {
  92     tree_->AddObserver(this);
  93   }
  94   ~TreeSizeMatchesObserver() override { tree_->RemoveObserver(this); }
  95
  96   bool IsTreeCorrectSize() { return CountViews(tree_) == tree_size_; }
  97
  98  private:
  99   // Overridden from ViewObserver:
 100   void OnTreeChanged(const TreeChangeParams& params) override {
 101     if (IsTreeCorrectSize())
 102       QuitRunLoop();
 103   }
 104
 105   size_t CountViews(const View* view) const {
 106     size_t count = 1;
 107     View::Children::const_iterator it = view->children().begin();
 108     for (; it != view->children().end(); ++it)
 109       count += CountViews(*it);
 110     return count;
 111   }
 112
 113   View* tree_;
 114   size_t tree_size_;
 115
 116   MOJO_DISALLOW_COPY_AND_ASSIGN(TreeSizeMatchesObserver);
 117 };
 118
 119 // Wait until |view|'s tree size matches |tree_size|; returns false on timeout.
 120 bool WaitForTreeSizeToMatch(View* view, size_t tree_size) {
 121   TreeSizeMatchesObserver observer(view, tree_size);
 122   return observer.IsTreeCorrectSize() || DoRunLoopWithTimeout();
 123 }
 124
 125 class OrderChangeObserver : public ViewObserver {
 126  public:
 127   OrderChangeObserver(View* view) : view_(view) { view_->AddObserver(this); }
 128   ~OrderChangeObserver() override { view_->RemoveObserver(this); }
 129
 130  private:
 131   // Overridden from ViewObserver:
 132   void OnViewReordered(View* view,
 133                        View* relative_view,
 134                        OrderDirection direction) override {
 135     DCHECK_EQ(view, view_);
 136     QuitRunLoop();
 137   }
 138
 139   View* view_;
 140
 141   MOJO_DISALLOW_COPY_AND_ASSIGN(OrderChangeObserver);
 142 };
 143
 144 // Wait until |view|'s tree size matches |tree_size|; returns false on timeout.
 145 bool WaitForOrderChange(ViewManager* view_manager, View* view) {
 146   OrderChangeObserver observer(view);
 147   return DoRunLoopWithTimeout();
 148 }
 149
 150 // Tracks a view's destruction. Query is_valid() for current state.
 151 class ViewTracker : public ViewObserver {
 152  public:
 153   explicit ViewTracker(View* view) : view_(view) { view_->AddObserver(this); }
 154   ~ViewTracker() override {
 155     if (view_)
 156       view_->RemoveObserver(this);
 157   }
 158
 159   bool is_valid() const { return !!view_; }
 160
 161  private:
 162   // Overridden from ViewObserver:
 163   void OnViewDestroyed(View* view) override {
 164     DCHECK_EQ(view, view_);
 165     view_ = nullptr;
 166   }
 167
 168   int id_;
 169   View* view_;
 170
 171   MOJO_DISALLOW_COPY_AND_ASSIGN(ViewTracker);
 172 };
 173
 174 }  // namespace
 175
 176 // ViewManager -----------------------------------------------------------------
 177
 178 // These tests model synchronization of two peer connections to the view manager
 179 // service, that are given access to some root view.
 180
 181 class ViewManagerTest : public test::ApplicationTestBase,
 182                         public ApplicationDelegate,
 183                         public ViewManagerDelegate {
 184  public:
 185   ViewManagerTest()
 186       : most_recent_view_manager_(nullptr), window_manager_(nullptr) {}
 187
 188   // Overridden from ApplicationDelegate:
 189   void Initialize(ApplicationImpl* app) override {
 190     view_manager_client_factory_.reset(
 191         new ViewManagerClientFactory(app->shell(), this));
 192   }
 193
 194   // ApplicationDelegate implementation.
 195   bool ConfigureIncomingConnection(ApplicationConnection* connection) override {
 196     connection->AddService(view_manager_client_factory_.get());
 197     return true;
 198   }
 199
 200   ViewManager* window_manager() { return window_manager_; }
 201
 202   // Embeds another version of the test app @ view; returns nullptr on timeout.
 203   ViewManager* Embed(ViewManager* view_manager, View* view) {
 204     DCHECK_EQ(view_manager, view->view_manager());
 205     most_recent_view_manager_ = nullptr;
 206     view->Embed(application_impl()->url());
 207     if (!DoRunLoopWithTimeout())
 208       return nullptr;
 209     ViewManager* vm = nullptr;
 210     std::swap(vm, most_recent_view_manager_);
 211     return vm;
 212   }
 213
 214   ApplicationDelegate* GetApplicationDelegate() override { return this; }
 215
 216   // Overridden from ViewManagerDelegate:
 217   void OnEmbed(View* root,
 218                InterfaceRequest<ServiceProvider> services,
 219                ServiceProviderPtr exposed_services) override {
 220     most_recent_view_manager_ = root->view_manager();
 221     QuitRunLoop();
 222   }
 223   void OnViewManagerDisconnected(ViewManager* view_manager) override {}
 224
 225  private:
 226   // Overridden from testing::Test:
 227   void SetUp() override {
 228     ApplicationTestBase::SetUp();
 229
 230     view_manager_init_.reset(
 231         new ViewManagerInit(application_impl(), this, nullptr));
 232     ASSERT_TRUE(DoRunLoopWithTimeout());
 233     std::swap(window_manager_, most_recent_view_manager_);
 234   }
 235
 236   // Overridden from testing::Test:
 237   void TearDown() override { ApplicationTestBase::TearDown(); }
 238
 239   scoped_ptr<ViewManagerInit> view_manager_init_;
 240
 241   scoped_ptr<ViewManagerClientFactory> view_manager_client_factory_;
 242
 243   // Used to receive the most recent view manager loaded by an embed action.
 244   ViewManager* most_recent_view_manager_;
 245   // The View Manager connection held by the window manager (app running at the
 246   // root view).
 247   ViewManager* window_manager_;
 248
 249   MOJO_DISALLOW_COPY_AND_ASSIGN(ViewManagerTest);
 250 };
 251
 252 TEST_F(ViewManagerTest, RootView) {
 253   ASSERT_NE(nullptr, window_manager());
 254   EXPECT_NE(nullptr, window_manager()->GetRoot());
 255   // No one embedded the window_manager(), so it has no url.
 256   EXPECT_TRUE(window_manager()->GetEmbedderURL().empty());
 257 }
 258
 259 TEST_F(ViewManagerTest, Embed) {
 260   View* view = window_manager()->CreateView();
 261   ASSERT_NE(nullptr, view);
 262   view->SetVisible(true);
 263   window_manager()->GetRoot()->AddChild(view);
 264   ViewManager* embedded = Embed(window_manager(), view);
 265   ASSERT_NE(nullptr, embedded);
 266
 267   View* view_in_embedded = embedded->GetRoot();
 268   ASSERT_NE(nullptr, view_in_embedded);
 269   EXPECT_EQ(view->id(), view_in_embedded->id());
 270   EXPECT_EQ(nullptr, view_in_embedded->parent());
 271   EXPECT_TRUE(view_in_embedded->children().empty());
 272 }
 273
 274 // Window manager has two views, N1 and N11. Embeds A at N1. A should not see
 275 // N11.
 276 TEST_F(ViewManagerTest, EmbeddedDoesntSeeChild) {
 277   View* view = window_manager()->CreateView();
 278   ASSERT_NE(nullptr, view);
 279   view->SetVisible(true);
 280   window_manager()->GetRoot()->AddChild(view);
 281   View* nested = window_manager()->CreateView();
 282   ASSERT_NE(nullptr, nested);
 283   nested->SetVisible(true);
 284   view->AddChild(nested);
 285
 286   ViewManager* embedded = Embed(window_manager(), view);
 287   ASSERT_NE(nullptr, embedded);
 288   View* view_in_embedded = embedded->GetRoot();
 289   EXPECT_EQ(view->id(), view_in_embedded->id());
 290   EXPECT_EQ(nullptr, view_in_embedded->parent());
 291   EXPECT_TRUE(view_in_embedded->children().empty());
 292 }
 293
 294 // TODO(beng): write a replacement test for the one that once existed here:
 295 // This test validates the following scenario:
 296 // -  a view originating from one connection
 297 // -  a view originating from a second connection
 298 // +  the connection originating the view is destroyed
 299 // -> the view should still exist (since the second connection is live) but
 300 //    should be disconnected from any views.
 301 // http://crbug.com/396300
 302 //
 303 // TODO(beng): The new test should validate the scenario as described above
 304 //             except that the second connection still has a valid tree.
 305
 306 // Verifies that bounds changes applied to a view hierarchy in one connection
 307 // are reflected to another.
 308 TEST_F(ViewManagerTest, SetBounds) {
 309   View* view = window_manager()->CreateView();
 310   view->SetVisible(true);
 311   window_manager()->GetRoot()->AddChild(view);
 312   ViewManager* embedded = Embed(window_manager(), view);
 313   ASSERT_NE(nullptr, embedded);
 314
 315   View* view_in_embedded = embedded->GetViewById(view->id());
 316   EXPECT_EQ(view->bounds(), view_in_embedded->bounds());
 317
 318   Rect rect;
 319   rect.width = rect.height = 100;
 320   view->SetBounds(rect);
 321   ASSERT_TRUE(WaitForBoundsToChange(view_in_embedded));
 322   EXPECT_EQ(view->bounds(), view_in_embedded->bounds());
 323 }
 324
 325 // Verifies that bounds changes applied to a view owned by a different
 326 // connection are refused.
 327 TEST_F(ViewManagerTest, SetBoundsSecurity) {
 328   View* view = window_manager()->CreateView();
 329   view->SetVisible(true);
 330   window_manager()->GetRoot()->AddChild(view);
 331   ViewManager* embedded = Embed(window_manager(), view);
 332   ASSERT_NE(nullptr, embedded);
 333
 334   View* view_in_embedded = embedded->GetViewById(view->id());
 335   Rect rect;
 336   rect.width = 800;
 337   rect.height = 600;
 338   view->SetBounds(rect);
 339   ASSERT_TRUE(WaitForBoundsToChange(view_in_embedded));
 340
 341   rect.width = 1024;
 342   rect.height = 768;
 343   view_in_embedded->SetBounds(rect);
 344   // Bounds change should have been rejected.
 345   EXPECT_EQ(view->bounds(), view_in_embedded->bounds());
 346 }
 347
 348 // Verifies that a view can only be destroyed by the connection that created it.
 349 TEST_F(ViewManagerTest, DestroySecurity) {
 350   View* view = window_manager()->CreateView();
 351   view->SetVisible(true);
 352   window_manager()->GetRoot()->AddChild(view);
 353   ViewManager* embedded = Embed(window_manager(), view);
 354   ASSERT_NE(nullptr, embedded);
 355
 356   View* view_in_embedded = embedded->GetViewById(view->id());
 357
 358   ViewTracker tracker2(view_in_embedded);
 359   view_in_embedded->Destroy();
 360   // View should not have been destroyed.
 361   EXPECT_TRUE(tracker2.is_valid());
 362
 363   ViewTracker tracker1(view);
 364   view->Destroy();
 365   EXPECT_FALSE(tracker1.is_valid());
 366 }
 367
 368 TEST_F(ViewManagerTest, MultiRoots) {
 369   View* view1 = window_manager()->CreateView();
 370   view1->SetVisible(true);
 371   window_manager()->GetRoot()->AddChild(view1);
 372   View* view2 = window_manager()->CreateView();
 373   view2->SetVisible(true);
 374   window_manager()->GetRoot()->AddChild(view2);
 375   ViewManager* embedded1 = Embed(window_manager(), view1);
 376   ASSERT_NE(nullptr, embedded1);
 377   ViewManager* embedded2 = Embed(window_manager(), view2);
 378   ASSERT_NE(nullptr, embedded2);
 379   EXPECT_NE(embedded1, embedded2);
 380 }
 381
 382 TEST_F(ViewManagerTest, EmbeddingIdentity) {
 383   View* view = window_manager()->CreateView();
 384   view->SetVisible(true);
 385   window_manager()->GetRoot()->AddChild(view);
 386   ViewManager* embedded = Embed(window_manager(), view);
 387   ASSERT_NE(nullptr, embedded);
 388   EXPECT_EQ(application_impl()->url(), embedded->GetEmbedderURL());
 389 }
 390
 391 // TODO(alhaad): Currently, the RunLoop gets stuck waiting for order change.
 392 // Debug and re-enable this.
 393 TEST_F(ViewManagerTest, DISABLED_Reorder) {
 394   View* view1 = window_manager()->CreateView();
 395   view1->SetVisible(true);
 396   window_manager()->GetRoot()->AddChild(view1);
 397
 398   ViewManager* embedded = Embed(window_manager(), view1);
 399   ASSERT_NE(nullptr, embedded);
 400
 401   View* view11 = embedded->CreateView();
 402   view11->SetVisible(true);
 403   embedded->GetRoot()->AddChild(view11);
 404   View* view12 = embedded->CreateView();
 405   view12->SetVisible(true);
 406   embedded->GetRoot()->AddChild(view12);
 407
 408   View* root_in_embedded = embedded->GetRoot();
 409
 410   {
 411     ASSERT_TRUE(WaitForTreeSizeToMatch(root_in_embedded, 3u));
 412     view11->MoveToFront();
 413     ASSERT_TRUE(WaitForOrderChange(embedded, root_in_embedded));
 414
 415     EXPECT_EQ(root_in_embedded->children().front(),
 416               embedded->GetViewById(view12->id()));
 417     EXPECT_EQ(root_in_embedded->children().back(),
 418               embedded->GetViewById(view11->id()));
 419   }
 420
 421   {
 422     view11->MoveToBack();
 423     ASSERT_TRUE(WaitForOrderChange(embedded,
 424                                    embedded->GetViewById(view11->id())));
 425
 426     EXPECT_EQ(root_in_embedded->children().front(),
 427               embedded->GetViewById(view11->id()));
 428     EXPECT_EQ(root_in_embedded->children().back(),
 429               embedded->GetViewById(view12->id()));
 430   }
 431 }
 432
 433 namespace {
 434
 435 class VisibilityChangeObserver : public ViewObserver {
 436  public:
 437   explicit VisibilityChangeObserver(View* view) : view_(view) {
 438     view_->AddObserver(this);
 439   }
 440   ~VisibilityChangeObserver() override { view_->RemoveObserver(this); }
 441
 442  private:
 443   // Overridden from ViewObserver:
 444   void OnViewVisibilityChanged(View* view) override {
 445     EXPECT_EQ(view, view_);
 446     QuitRunLoop();
 447   }
 448
 449   View* view_;
 450
 451   MOJO_DISALLOW_COPY_AND_ASSIGN(VisibilityChangeObserver);
 452 };
 453
 454 }  // namespace
 455
 456 TEST_F(ViewManagerTest, Visible) {
 457   View* view1 = window_manager()->CreateView();
 458   view1->SetVisible(true);
 459   window_manager()->GetRoot()->AddChild(view1);
 460
 461   // Embed another app and verify initial state.
 462   ViewManager* embedded = Embed(window_manager(), view1);
 463   ASSERT_NE(nullptr, embedded);
 464   ASSERT_NE(nullptr, embedded->GetRoot());
 465   View* embedded_root = embedded->GetRoot();
 466   EXPECT_TRUE(embedded_root->visible());
 467   EXPECT_TRUE(embedded_root->IsDrawn());
 468
 469   // Change the visible state from the first connection and verify its mirrored
 470   // correctly to the embedded app.
 471   {
 472     VisibilityChangeObserver observer(embedded_root);
 473     view1->SetVisible(false);
 474     ASSERT_TRUE(DoRunLoopWithTimeout());
 475   }
 476
 477   EXPECT_FALSE(view1->visible());
 478   EXPECT_FALSE(view1->IsDrawn());
 479
 480   EXPECT_FALSE(embedded_root->visible());
 481   EXPECT_FALSE(embedded_root->IsDrawn());
 482
 483   // Make the node visible again.
 484   {
 485     VisibilityChangeObserver observer(embedded_root);
 486     view1->SetVisible(true);
 487     ASSERT_TRUE(DoRunLoopWithTimeout());
 488   }
 489
 490   EXPECT_TRUE(view1->visible());
 491   EXPECT_TRUE(view1->IsDrawn());
 492
 493   EXPECT_TRUE(embedded_root->visible());
 494   EXPECT_TRUE(embedded_root->IsDrawn());
 495 }
 496
 497 namespace {
 498
 499 class DrawnChangeObserver : public ViewObserver {
 500  public:
 501   explicit DrawnChangeObserver(View* view) : view_(view) {
 502     view_->AddObserver(this);
 503   }
 504   ~DrawnChangeObserver() override { view_->RemoveObserver(this); }
 505
 506  private:
 507   // Overridden from ViewObserver:
 508   void OnViewDrawnChanged(View* view) override {
 509     EXPECT_EQ(view, view_);
 510     QuitRunLoop();
 511   }
 512
 513   View* view_;
 514
 515   MOJO_DISALLOW_COPY_AND_ASSIGN(DrawnChangeObserver);
 516 };
 517
 518 }  // namespace
 519
 520 TEST_F(ViewManagerTest, Drawn) {
 521   View* view1 = window_manager()->CreateView();
 522   view1->SetVisible(true);
 523   window_manager()->GetRoot()->AddChild(view1);
 524
 525   // Embed another app and verify initial state.
 526   ViewManager* embedded = Embed(window_manager(), view1);
 527   ASSERT_NE(nullptr, embedded);
 528   ASSERT_NE(nullptr, embedded->GetRoot());
 529   View* embedded_root = embedded->GetRoot();
 530   EXPECT_TRUE(embedded_root->visible());
 531   EXPECT_TRUE(embedded_root->IsDrawn());
 532
 533   // Change the visibility of the root, this should propagate a drawn state
 534   // change to |embedded|.
 535   {
 536     DrawnChangeObserver observer(embedded_root);
 537     window_manager()->GetRoot()->SetVisible(false);
 538     ASSERT_TRUE(DoRunLoopWithTimeout());
 539   }
 540
 541   EXPECT_TRUE(view1->visible());
 542   EXPECT_FALSE(view1->IsDrawn());
 543
 544   EXPECT_TRUE(embedded_root->visible());
 545   EXPECT_FALSE(embedded_root->IsDrawn());
 546 }
 547
 548 // TODO(beng): tests for view event dispatcher.
 549 // - verify that we see events for all views.
 550
 551 namespace {
 552
 553 class FocusChangeObserver : public ViewObserver {
 554  public:
 555   explicit FocusChangeObserver(View* view)
 556       : view_(view), last_gained_focus_(nullptr), last_lost_focus_(nullptr) {
 557     view_->AddObserver(this);
 558   }
 559   ~FocusChangeObserver() override { view_->RemoveObserver(this); }
 560
 561   View* last_gained_focus() { return last_gained_focus_; }
 562
 563   View* last_lost_focus() { return last_lost_focus_; }
 564
 565  private:
 566   // Overridden from ViewObserver.
 567   void OnViewFocusChanged(View* gained_focus, View* lost_focus) override {
 568     last_gained_focus_ = gained_focus;
 569     last_lost_focus_ = lost_focus;
 570     QuitRunLoop();
 571   }
 572
 573   View* view_;
 574   View* last_gained_focus_;
 575   View* last_lost_focus_;
 576
 577   MOJO_DISALLOW_COPY_AND_ASSIGN(FocusChangeObserver);
 578 };
 579
 580 }  // namespace
 581
 582 TEST_F(ViewManagerTest, Focus) {
 583   View* view1 = window_manager()->CreateView();
 584   view1->SetVisible(true);
 585   window_manager()->GetRoot()->AddChild(view1);
 586
 587   ViewManager* embedded = Embed(window_manager(), view1);
 588   ASSERT_NE(nullptr, embedded);
 589   View* view11 = embedded->CreateView();
 590   view11->SetVisible(true);
 591   embedded->GetRoot()->AddChild(view11);
 592
 593   // TODO(alhaad): Figure out why switching focus between views from different
 594   // connections is causing the tests to crash and add tests for that.
 595   {
 596     View* embedded_root = embedded->GetRoot();
 597     FocusChangeObserver observer(embedded_root);
 598     embedded_root->SetFocus();
 599     ASSERT_TRUE(DoRunLoopWithTimeout());
 600     ASSERT_NE(nullptr, observer.last_gained_focus());
 601     EXPECT_EQ(embedded_root->id(), observer.last_gained_focus()->id());
 602   }
 603   {
 604     FocusChangeObserver observer(view11);
 605     view11->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_gained_focus()->id());
 610     EXPECT_EQ(embedded->GetRoot()->id(), observer.last_lost_focus()->id());
 611   }
 612 }
 613
 614 }  // namespace mojo