Update mojo sdk to rev 59145288bae55b0fce4276b017df6a1117bcf00f

mojo/services/view_manager/public/cpp/tests/view_manager_unittest.cc

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#include "mojo/services/public/cpp/view_manager/view_manager.h"
+#include "mojo/services/view_manager/public/cpp/view_manager.h"
 
 #include "base/auto_reset.h"
 #include "base/bind.h"
 #include "base/logging.h"
 #include "mojo/application_manager/application_manager.h"
 #include "mojo/public/cpp/application/application_connection.h"
 #include "mojo/public/cpp/application/application_delegate.h"
 #include "mojo/public/cpp/application/application_impl.h"
 #include "mojo/public/cpp/application/service_provider_impl.h"
 #include "mojo/public/interfaces/application/service_provider.mojom.h"
-#include "mojo/services/public/cpp/geometry/geometry_util.h"
-#include "mojo/services/public/cpp/view_manager/lib/view_manager_client_impl.h"
-#include "mojo/services/public/cpp/view_manager/lib/view_private.h"
-#include "mojo/services/public/cpp/view_manager/util.h"
-#include "mojo/services/public/cpp/view_manager/view_manager_client_factory.h"
-#include "mojo/services/public/cpp/view_manager/view_manager_delegate.h"
-#include "mojo/services/public/cpp/view_manager/view_observer.h"
+#include "mojo/services/geometry/public/cpp/geometry_util.h"
+#include "mojo/services/view_manager/public/cpp/lib/view_manager_client_impl.h"
+#include "mojo/services/view_manager/public/cpp/lib/view_private.h"
+#include "mojo/services/view_manager/public/cpp/util.h"
+#include "mojo/services/view_manager/public/cpp/view_manager_client_factory.h"
+#include "mojo/services/view_manager/public/cpp/view_manager_delegate.h"
+#include "mojo/services/view_manager/public/cpp/view_observer.h"
 #include "shell/shell_test_helper.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace mojo {
 
 namespace {
 
 const char kWindowManagerURL[] = "mojo:window_manager";
 const char kEmbeddedApp1URL[] = "mojo:embedded_app_1";
 
@@ skipping 309 matching lines @@
 };
 
 // TODO(sky): all of these tests are disabled as each test triggers running
 // ViewsInit, which tries to register the same set of paths with the
 // PathService, triggering a DCHECK.
 TEST_F(ViewManagerTest, DISABLED_SetUp) {}
 
 TEST_F(ViewManagerTest, DISABLED_Embed) {
   View* view = View::Create(window_manager());
   view->SetVisible(true);
-  window_manager()->GetRoots().front()->AddChild(view);
+  window_manager()->GetRoot()->AddChild(view);
   ViewManager* embedded = Embed(window_manager(), view);
   EXPECT_TRUE(NULL != embedded);
 
-  View* view_in_embedded = embedded->GetRoots().front();
-  EXPECT_EQ(view->parent(), window_manager()->GetRoots().front());
+  View* view_in_embedded = embedded->GetRoot();
+  EXPECT_EQ(view->parent(), window_manager()->GetRoot());
   EXPECT_EQ(NULL, view_in_embedded->parent());
 }
 
 // Window manager has two views, N1 and N11. Embeds A at N1. A should not see
 // N11.
 // TODO(sky): Update client lib to match server.
 TEST_F(ViewManagerTest, DISABLED_EmbeddedDoesntSeeChild) {
   View* view = View::Create(window_manager());
   view->SetVisible(true);
-  window_manager()->GetRoots().front()->AddChild(view);
+  window_manager()->GetRoot()->AddChild(view);
   View* nested = View::Create(window_manager());
   nested->SetVisible(true);
   view->AddChild(nested);
 
   ViewManager* embedded = Embed(window_manager(), view);
-  EXPECT_EQ(embedded->GetRoots().front()->children().front()->id(),
+  EXPECT_EQ(embedded->GetRoot()->children().front()->id(),
             nested->id());
-  EXPECT_TRUE(embedded->GetRoots().front()->children().empty());
+  EXPECT_TRUE(embedded->GetRoot()->children().empty());
   EXPECT_TRUE(nested->parent() == NULL);
 }
 
 // http://crbug.com/396300
 TEST_F(ViewManagerTest, DISABLED_ViewManagerDestroyed_CleanupView) {
   View* view = View::Create(window_manager());
   view->SetVisible(true);
-  window_manager()->GetRoots().front()->AddChild(view);
+  window_manager()->GetRoot()->AddChild(view);
   ViewManager* embedded = Embed(window_manager(), view);
 
   Id view_id = view->id();
 
   UnloadApplication(GURL(kWindowManagerURL));
 
   std::set<Id> views;
   views.insert(view_id);
   WaitForDestruction(embedded, &views);
 
-  EXPECT_TRUE(embedded->GetRoots().empty());
+  EXPECT_EQ(nullptr, embedded->GetRoot());
 }
 
 // TODO(beng): write a replacement test for the one that once existed here:
 // This test validates the following scenario:
 // -  a view originating from one connection
 // -  a view originating from a second connection
 // +  the connection originating the view is destroyed
 // -> the view should still exist (since the second connection is live) but
 //    should be disconnected from any views.
 // http://crbug.com/396300
 //
 // TODO(beng): The new test should validate the scenario as described above
 //             except that the second connection still has a valid tree.
 
 // Verifies that bounds changes applied to a view hierarchy in one connection
 // are reflected to another.
 TEST_F(ViewManagerTest, DISABLED_SetBounds) {
   View* view = View::Create(window_manager());
   view->SetVisible(true);
-  window_manager()->GetRoots().front()->AddChild(view);
+  window_manager()->GetRoot()->AddChild(view);
   ViewManager* embedded = Embed(window_manager(), view);
 
   View* view_in_embedded = embedded->GetViewById(view->id());
   EXPECT_EQ(view->bounds(), view_in_embedded->bounds());
 
   Rect rect;
   rect.width = rect.height = 100;
   view->SetBounds(rect);
   EXPECT_NE(view->bounds(), view_in_embedded->bounds());
   WaitForBoundsToChange(view_in_embedded);
   EXPECT_EQ(view->bounds(), view_in_embedded->bounds());
 }
 
 // Verifies that bounds changes applied to a view owned by a different
 // connection are refused.
 TEST_F(ViewManagerTest, DISABLED_SetBoundsSecurity) {
   View* view = View::Create(window_manager());
   view->SetVisible(true);
-  window_manager()->GetRoots().front()->AddChild(view);
+  window_manager()->GetRoot()->AddChild(view);
   ViewManager* embedded = Embed(window_manager(), view);
 
   View* view_in_embedded = embedded->GetViewById(view->id());
   Rect rect;
   rect.width = 800;
   rect.height = 600;
   view->SetBounds(rect);
   WaitForBoundsToChange(view_in_embedded);
 
   rect.width = 1024;
   rect.height = 768;
   view_in_embedded->SetBounds(rect);
   // Bounds change should have been rejected.
   EXPECT_EQ(view->bounds(), view_in_embedded->bounds());
 }
 
 // Verifies that a view can only be destroyed by the connection that created it.
 TEST_F(ViewManagerTest, DISABLED_DestroySecurity) {
   View* view = View::Create(window_manager());
   view->SetVisible(true);
-  window_manager()->GetRoots().front()->AddChild(view);
+  window_manager()->GetRoot()->AddChild(view);
   ViewManager* embedded = Embed(window_manager(), view);
 
   View* view_in_embedded = embedded->GetViewById(view->id());
 
   ViewTracker tracker2(view_in_embedded);
   view_in_embedded->Destroy();
   // View should not have been destroyed.
   EXPECT_TRUE(tracker2.is_valid());
 
   ViewTracker tracker1(view);
   view->Destroy();
   EXPECT_FALSE(tracker1.is_valid());
 }
 
 TEST_F(ViewManagerTest, DISABLED_MultiRoots) {
   View* view1 = View::Create(window_manager());
   view1->SetVisible(true);
-  window_manager()->GetRoots().front()->AddChild(view1);
+  window_manager()->GetRoot()->AddChild(view1);
   View* view2 = View::Create(window_manager());
   view2->SetVisible(true);
-  window_manager()->GetRoots().front()->AddChild(view2);
+  window_manager()->GetRoot()->AddChild(view2);
   ViewManager* embedded1 = Embed(window_manager(), view1);
   ViewManager* embedded2 = Embed(window_manager(), view2);
   EXPECT_EQ(embedded1, embedded2);
 }
 
 TEST_F(ViewManagerTest, DISABLED_EmbeddingIdentity) {
   View* view = View::Create(window_manager());
   view->SetVisible(true);
-  window_manager()->GetRoots().front()->AddChild(view);
+  window_manager()->GetRoot()->AddChild(view);
   ViewManager* embedded = Embed(window_manager(), view);
   EXPECT_EQ(kWindowManagerURL, embedded->GetEmbedderURL());
 }
 
 TEST_F(ViewManagerTest, DISABLED_Reorder) {
   View* view1 = View::Create(window_manager());
   view1->SetVisible(true);
-  window_manager()->GetRoots().front()->AddChild(view1);
+  window_manager()->GetRoot()->AddChild(view1);
 
   ViewManager* embedded = Embed(window_manager(), view1);
 
   View* view11 = View::Create(embedded);
   view11->SetVisible(true);
-  embedded->GetRoots().front()->AddChild(view11);
+  embedded->GetRoot()->AddChild(view11);
   View* view12 = View::Create(embedded);
   view12->SetVisible(true);
-  embedded->GetRoots().front()->AddChild(view12);
+  embedded->GetRoot()->AddChild(view12);
 
   View* view1_in_wm = window_manager()->GetViewById(view1->id());
 
   {
     WaitForTreeSizeToMatch(view1, 2u);
     view11->MoveToFront();
     WaitForOrderChange(window_manager(),
                        window_manager()->GetViewById(view11->id()));
 
     EXPECT_EQ(view1_in_wm->children().front(),
@@ skipping 33 matching lines @@
   View* view_;
 
   DISALLOW_COPY_AND_ASSIGN(VisibilityChangeObserver);
 };
 
 }  // namespace
 
 TEST_F(ViewManagerTest, DISABLED_Visible) {
   View* view1 = View::Create(window_manager());
   view1->SetVisible(true);
-  window_manager()->GetRoots().front()->AddChild(view1);
+  window_manager()->GetRoot()->AddChild(view1);
 
   // Embed another app and verify initial state.
   ViewManager* embedded = Embed(window_manager(), view1);
-  ASSERT_EQ(1u, embedded->GetRoots().size());
-  View* embedded_root = embedded->GetRoots().front();
+  ASSERT_NE(nullptr, embedded->GetRoot());
+  View* embedded_root = embedded->GetRoot();
   EXPECT_TRUE(embedded_root->visible());
   EXPECT_TRUE(embedded_root->IsDrawn());
 
   // Change the visible state from the first connection and verify its mirrored
   // correctly to the embedded app.
   {
     VisibilityChangeObserver observer(embedded_root);
     view1->SetVisible(false);
     DoRunLoop();
   }
@@ skipping 37 matching lines @@
   View* view_;
 
   DISALLOW_COPY_AND_ASSIGN(DrawnChangeObserver);
 };
 
 }  // namespace
 
 TEST_F(ViewManagerTest, DISABLED_Drawn) {
   View* view1 = View::Create(window_manager());
   view1->SetVisible(true);
-  window_manager()->GetRoots().front()->AddChild(view1);
+  window_manager()->GetRoot()->AddChild(view1);
 
   // Embed another app and verify initial state.
   ViewManager* embedded = Embed(window_manager(), view1);
-  ASSERT_EQ(1u, embedded->GetRoots().size());
-  View* embedded_root = embedded->GetRoots().front();
+  ASSERT_NE(nullptr, embedded->GetRoot());
+  View* embedded_root = embedded->GetRoot();
   EXPECT_TRUE(embedded_root->visible());
   EXPECT_TRUE(embedded_root->IsDrawn());
 
   // Change the visibility of the root, this should propagate a drawn state
   // change to |embedded|.
   {
     DrawnChangeObserver observer(embedded_root);
-    window_manager()->GetRoots().front()->SetVisible(false);
+    window_manager()->GetRoot()->SetVisible(false);
     DoRunLoop();
   }
 
   EXPECT_TRUE(view1->visible());
   EXPECT_FALSE(view1->IsDrawn());
 
   EXPECT_TRUE(embedded_root->visible());
   EXPECT_FALSE(embedded_root->IsDrawn());
 }
 
 // TODO(beng): tests for view event dispatcher.
 // - verify that we see events for all views.
 
 // TODO(beng): tests for focus:
 // - focus between two views known to a connection
 // - focus between views unknown to one of the connections.
 // - focus between views unknown to either connection.
 
 // TODO(sky): need test of root being destroyed with existing views. See
 // 434555 for specific case.
 
 }  // namespace mojo