Makes it so each windowtreeclient can use whatever ids it wants

components/mus/ws/window_tree_apptest.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 <stddef.h>
 #include <stdint.h>
 
 #include "base/bind.h"
 #include "base/macros.h"
 #include "base/message_loop/message_loop.h"
@@ skipping 111 matching lines @@
                                  public TestChangeTracker::Delegate {
  public:
   TestWindowTreeClientImpl()
       : binding_(this),
         connection_id_(0),
         root_window_id_(0),
         // Start with a random large number so tests can use lower ids if they
         // want.
         next_change_id_(10000),
         waiting_change_id_(0),
-        on_change_completed_result_(false) {
+        on_change_completed_result_(false),
+        track_root_bounds_changes_(false) {
     tracker_.set_delegate(this);
   }
 
   void Bind(mojo::InterfaceRequest<mojom::WindowTreeClient> request) {
     binding_.Bind(std::move(request));
   }
 
   mojom::WindowTree* tree() { return tree_.get(); }
   TestChangeTracker* tracker() { return &tracker_; }
+  Id root_window_id() const { return root_window_id_; }
+
+  // Sets whether changes to the bounds of the root should be tracked. Normally
+  // they are ignored (as during startup we often times get random size
+  // changes).
+  void set_track_root_bounds_changes(bool value) {
+    track_root_bounds_changes_ = value;
+  }
 
   // Runs a nested MessageLoop until |count| changes (calls to
   // WindowTreeClient functions) have been received.
   void WaitForChangeCount(size_t count) {
     if (tracker_.changes()->size() >= count)
       return;
 
     ASSERT_TRUE(wait_state_.get() == nullptr);
     wait_state_.reset(new WaitState);
     wait_state_->change_count = count;
@@ skipping 63 matching lines @@
 
   // Generally you want NewWindow(), but use this if you need to test given
   // a complete window id (NewWindow() ors with the connection id).
   Id NewWindowWithCompleteId(Id id) {
     mojo::Map<mojo::String, mojo::Array<uint8_t>> properties;
     const uint32_t change_id = GetAndAdvanceChangeId();
     tree()->NewWindow(change_id, id, std::move(properties));
     return WaitForChangeCompleted(change_id) ? id : 0;
   }
 
-  void set_root_window(Id root_window_id) { root_window_id_ = root_window_id; }
-
   bool SetWindowProperty(Id window_id,
                          const std::string& name,
                          const std::vector<uint8_t>* data) {
     Array<uint8_t> mojo_data;
     if (data)
       mojo_data = Array<uint8_t>::From(*data);
     const uint32_t change_id = GetAndAdvanceChangeId();
     tree()->SetWindowProperty(change_id, window_id, name, std::move(mojo_data));
     return WaitForChangeCompleted(change_id);
   }
@@ skipping 28 matching lines @@
     }
   }
 
   // WindowTreeClient:
   void OnEmbed(ConnectionSpecificId connection_id,
                WindowDataPtr root,
                mojom::WindowTreePtr tree,
                Id focused_window_id,
                uint32_t access_policy) override {
     // TODO(sky): add coverage of |focused_window_id|.
+    ASSERT_TRUE(root);
+    root_window_id_ = root->window_id;
     tree_ = std::move(tree);
     connection_id_ = connection_id;
     tracker()->OnEmbed(connection_id, std::move(root));
     if (embed_run_loop_)
       embed_run_loop_->Quit();
   }
   void OnEmbeddedAppDisconnected(Id window_id) override {
     tracker()->OnEmbeddedAppDisconnected(window_id);
   }
   void OnUnembed(Id window_id) override { tracker()->OnUnembed(window_id); }
   void OnTopLevelCreated(uint32_t change_id,
                          mojom::WindowDataPtr data) override {
     tracker()->OnTopLevelCreated(change_id, std::move(data));
   }
   void OnWindowBoundsChanged(Id window_id,
                              RectPtr old_bounds,
                              RectPtr new_bounds) override {
     // The bounds of the root may change during startup on Android at random
     // times. As this doesn't matter, and shouldn't impact test exepctations,
     // it is ignored.
-    if (window_id == root_window_id_)
+    if (window_id == root_window_id_ && !track_root_bounds_changes_)
       return;
     tracker()->OnWindowBoundsChanged(window_id, std::move(old_bounds),
                                      std::move(new_bounds));
   }
   void OnClientAreaChanged(
       uint32_t window_id,
       mojo::InsetsPtr new_client_area,
       mojo::Array<mojo::RectPtr> new_additional_client_areas) override {}
   void OnTransientWindowAdded(uint32_t window_id,
                               uint32_t transient_window_id) override {
@@ skipping 68 matching lines @@
   // If non-null we're waiting for a certain number of change notifications to
   // be encountered.
   scoped_ptr<WaitState> wait_state_;
 
   mojo::Binding<WindowTreeClient> binding_;
   Id connection_id_;
   Id root_window_id_;
   uint32_t next_change_id_;
   uint32_t waiting_change_id_;
   bool on_change_completed_result_;
+  bool track_root_bounds_changes_;
   scoped_ptr<base::RunLoop> change_completed_run_loop_;
 
   DISALLOW_COPY_AND_ASSIGN(TestWindowTreeClientImpl);
 };
 
 // -----------------------------------------------------------------------------
 
 // InterfaceFactory for vending TestWindowTreeClientImpls.
 class WindowTreeClientFactory
     : public mojo::InterfaceFactory<WindowTreeClient> {
@@ skipping 57 matching lines @@
 
   int connection_id_1() const { return connection_id_1_; }
   int connection_id_2() const { return connection_id_2_; }
 
   void EstablishSecondConnectionWithRoot(Id root_id) {
     ASSERT_TRUE(ws_client2_.get() == nullptr);
     ws_client2_ =
         EstablishConnectionViaEmbed(ws1(), root_id, &connection_id_2_);
     ASSERT_GT(connection_id_2_, 0);
     ASSERT_TRUE(ws_client2_.get() != nullptr);
-    ws_client2_->set_root_window(root_window_id_);
   }
 
   void EstablishSecondConnection(bool create_initial_window) {
     Id window_1_1 = 0;
     if (create_initial_window) {
       window_1_1 = ws_client1()->NewWindow(1);
       ASSERT_TRUE(window_1_1);
     }
     ASSERT_NO_FATAL_FAILURE(
         EstablishSecondConnectionWithRoot(BuildWindowId(connection_id_1(), 1)));
 
     if (create_initial_window) {
       EXPECT_EQ("[" + WindowParentToString(window_1_1, kNullParentId) + "]",
                 ChangeWindowDescription(*changes2()));
     }
   }
 
   void EstablishThirdConnection(WindowTree* owner, Id root_id) {
     ASSERT_TRUE(ws_client3_.get() == nullptr);
     ws_client3_ = EstablishConnectionViaEmbed(owner, root_id, nullptr);
     ASSERT_TRUE(ws_client3_.get() != nullptr);
-    ws_client3_->set_root_window(root_window_id_);
   }
 
   scoped_ptr<TestWindowTreeClientImpl> WaitForWindowTreeClient() {
     return client_factory_->WaitForInstance();
   }
 
   // Establishes a new connection by way of Embed() on the specified
   // WindowTree.
   scoped_ptr<TestWindowTreeClientImpl> EstablishConnectionViaEmbed(
       WindowTree* owner,
@@ skipping 50 matching lines @@
 
     ASSERT_EQ(1u, changes1()->size());
     EXPECT_EQ(CHANGE_TYPE_EMBED, (*changes1())[0].type);
     // All these tests assume 1 for the client id. The only real assertion here
     // is the client id is not zero, but adding this as rest of code here
     // assumes 1.
     ASSERT_GT((*changes1())[0].connection_id, 0);
     connection_id_1_ = (*changes1())[0].connection_id;
     ASSERT_FALSE((*changes1())[0].windows.empty());
     root_window_id_ = (*changes1())[0].windows[0].window_id;
-    ws_client1_->set_root_window(root_window_id_);
+    ASSERT_EQ(root_window_id_, ws_client1_->root_window_id());
     changes1()->clear();
   }
 
   // ApplicationDelegate implementation.
   bool ConfigureIncomingConnection(ApplicationConnection* connection) override {
     connection->AddService(client_factory_.get());
     return true;
   }
 
   scoped_ptr<TestWindowTreeClientImpl> ws_client1_;
@@ skipping 77 matching lines @@
     windows.clear();
     GetWindowTree(ws2(), window_2_4, &windows);
     EXPECT_EQ(WindowParentToString(window_2_4, kNullParentId),
               SingleWindowDescription(windows));
   }
 
   // And window 4 should not be visible to connection 3.
   {
     std::vector<TestWindow> windows;
     GetWindowTree(ws3(), window_2_3, &windows);
-    EXPECT_EQ(WindowParentToString(window_2_3, kNullParentId),
-              SingleWindowDescription(windows));
+    EXPECT_EQ("no windows", SingleWindowDescription(windows));
   }
 }
 
 // Verifies once Embed() has been invoked the parent connection can't see any
 // children.
 TEST_F(WindowTreeAppTest, CantAccessChildrenOfEmbeddedWindow) {
   ASSERT_NO_FATAL_FAILURE(EstablishSecondConnection(true));
 
   Id window_1_1 = BuildWindowId(connection_id_1(), 1);
   Id window_2_2 = ws_client2()->NewWindow(2);
   ASSERT_TRUE(window_2_2);
   ASSERT_TRUE(ws_client2()->AddWindow(window_1_1, window_2_2));
 
   ASSERT_NO_FATAL_FAILURE(EstablishThirdConnection(ws2(), window_2_2));
 
   Id window_3_3 = ws_client3()->NewWindow(3);
   ASSERT_TRUE(window_3_3);
-  ASSERT_TRUE(ws_client3()->AddWindow(window_2_2, window_3_3));
+  ASSERT_TRUE(
+      ws_client3()->AddWindow(ws_client3()->root_window_id(), window_3_3));
 
   // Even though 3 is a child of 2 connection 2 can't see 3 as it's from a
   // different connection.
   {
     std::vector<TestWindow> windows;
     GetWindowTree(ws2(), window_2_2, &windows);
     EXPECT_EQ(WindowParentToString(window_2_2, window_1_1),
               SingleWindowDescription(windows));
   }
 
   // Connection 2 shouldn't be able to get window 3 at all.
   {
     std::vector<TestWindow> windows;
     GetWindowTree(ws2(), window_3_3, &windows);
     EXPECT_TRUE(windows.empty());
   }
 
   // Connection 1 should be able to see it all (its the root).
   {
     std::vector<TestWindow> windows;
     GetWindowTree(ws1(), window_1_1, &windows);
     ASSERT_EQ(3u, windows.size());
     EXPECT_EQ(WindowParentToString(window_1_1, kNullParentId),
               windows[0].ToString());
-    EXPECT_EQ(WindowParentToString(window_2_2, window_1_1),
-              windows[1].ToString());
-    EXPECT_EQ(WindowParentToString(window_3_3, window_2_2),
-              windows[2].ToString());
+    // NOTE: we expect a match of WindowParentToString(window_2_2, window_1_1),
+    // but the ids are in the id space of client2, which is not the same as
+    // the id space of ws1().
+    EXPECT_EQ("window=2,1 parent=1,1", windows[1].ToString());
+    // Same thing here, we really want to test for
+    // WindowParentToString(window_3_3, window_2_2).
+    EXPECT_EQ("window=3,1 parent=2,1", windows[2].ToString());
   }
 }
 
 // Verifies once Embed() has been invoked the parent can't mutate the children.
 TEST_F(WindowTreeAppTest, CantModifyChildrenOfEmbeddedWindow) {
   ASSERT_NO_FATAL_FAILURE(EstablishSecondConnection(true));
 
   Id window_1_1 = BuildWindowId(connection_id_1(), 1);
+  Id window_2_1 = ws_client2()->NewWindow(1);
+  ASSERT_TRUE(window_2_1);
+  ASSERT_TRUE(ws_client2()->AddWindow(window_1_1, window_2_1));
+
+  ASSERT_NO_FATAL_FAILURE(EstablishThirdConnection(ws2(), window_2_1));
+
   Id window_2_2 = ws_client2()->NewWindow(2);
   ASSERT_TRUE(window_2_2);
-  ASSERT_TRUE(ws_client2()->AddWindow(window_1_1, window_2_2));
-
-  ASSERT_NO_FATAL_FAILURE(EstablishThirdConnection(ws2(), window_2_2));
-
-  Id window_2_3 = ws_client2()->NewWindow(3);
-  ASSERT_TRUE(window_2_3);
   // Connection 2 shouldn't be able to add anything to the window anymore.
-  ASSERT_FALSE(ws_client2()->AddWindow(window_2_2, window_2_3));
+  ASSERT_FALSE(ws_client2()->AddWindow(window_2_1, window_2_2));
 
   // Create window 3 in connection 3 and add it to window 3.
-  Id window_3_3 = ws_client3()->NewWindow(3);
-  ASSERT_TRUE(window_3_3);
-  ASSERT_TRUE(ws_client3()->AddWindow(window_2_2, window_3_3));
+  Id window_3_1 = ws_client3()->NewWindow(1);
+  ASSERT_TRUE(window_3_1);
+  ASSERT_TRUE(ws_client3()->AddWindow(window_2_1, window_3_1));
 
   // Connection 2 shouldn't be able to remove window 3.
-  ASSERT_FALSE(ws_client2()->RemoveWindowFromParent(window_3_3));
+  ASSERT_FALSE(ws_client2()->RemoveWindowFromParent(window_3_1));
 }
 
 // Verifies client gets a valid id.
 TEST_F(WindowTreeAppTest, NewWindow) {
   Id window_1_1 = ws_client1()->NewWindow(1);
   ASSERT_TRUE(window_1_1);
   EXPECT_TRUE(changes1()->empty());
 
   // Can't create a window with the same id.
   ASSERT_EQ(0u, ws_client1()->NewWindowWithCompleteId(window_1_1));
   EXPECT_TRUE(changes1()->empty());
 
   // Can't create a window with a bogus connection id.
   ASSERT_EQ(0u, ws_client1()->NewWindowWithCompleteId(
                     BuildWindowId(connection_id_1() + 1, 1)));
   EXPECT_TRUE(changes1()->empty());
 }
 
 // Verifies AddWindow fails when window is already in position.
 TEST_F(WindowTreeAppTest, AddWindowWithNoChange) {
+  // Create the embed point now so that the ids line up.
+  ASSERT_TRUE(ws_client1()->NewWindow(1));
   Id window_1_2 = ws_client1()->NewWindow(2);
   Id window_1_3 = ws_client1()->NewWindow(3);
   ASSERT_TRUE(window_1_2);
   ASSERT_TRUE(window_1_3);
 
-  ASSERT_NO_FATAL_FAILURE(EstablishSecondConnection(true));
+  ASSERT_NO_FATAL_FAILURE(EstablishSecondConnection(false));
 
   // Make 3 a child of 2.
   ASSERT_TRUE(ws_client1()->AddWindow(window_1_2, window_1_3));
 
   // Try again, this should fail.
   EXPECT_FALSE(ws_client1()->AddWindow(window_1_2, window_1_3));
 }
 
 // Verifies AddWindow fails when window is already in position.
 TEST_F(WindowTreeAppTest, AddAncestorFails) {
+  // Create the embed point now so that the ids line up.
+  ASSERT_TRUE(ws_client1()->NewWindow(1));
   Id window_1_2 = ws_client1()->NewWindow(2);
   Id window_1_3 = ws_client1()->NewWindow(3);
   ASSERT_TRUE(window_1_2);
   ASSERT_TRUE(window_1_3);
 
-  ASSERT_NO_FATAL_FAILURE(EstablishSecondConnection(true));
+  ASSERT_NO_FATAL_FAILURE(EstablishSecondConnection(false));
 
   // Make 3 a child of 2.
   ASSERT_TRUE(ws_client1()->AddWindow(window_1_2, window_1_3));
 
   // Try to make 2 a child of 3, this should fail since 2 is an ancestor of 3.
   EXPECT_FALSE(ws_client1()->AddWindow(window_1_3, window_1_2));
 }
 
 // Verifies adding to root sends right notifications.
 TEST_F(WindowTreeAppTest, AddToRoot) {
+  // Create the embed point now so that the ids line up.
+  Id window_1_1 = ws_client1()->NewWindow(1);
+  ASSERT_TRUE(window_1_1);
   Id window_1_21 = ws_client1()->NewWindow(21);
   Id window_1_3 = ws_client1()->NewWindow(3);
   ASSERT_TRUE(window_1_21);
   ASSERT_TRUE(window_1_3);
 
-  Id window_1_1 = BuildWindowId(connection_id_1(), 1);
-  ASSERT_NO_FATAL_FAILURE(EstablishSecondConnection(true));
+  ASSERT_NO_FATAL_FAILURE(EstablishSecondConnection(false));
   changes2()->clear();
 
   // Make 3 a child of 21.
   ASSERT_TRUE(ws_client1()->AddWindow(window_1_21, window_1_3));
 
   // Make 21 a child of 1.
   ASSERT_TRUE(ws_client1()->AddWindow(window_1_1, window_1_21));
 
   // Connection 2 should not be told anything (because the window is from a
   // different connection). Create a window to ensure we got a response from
   // the server.
   ASSERT_TRUE(ws_client2()->NewWindow(100));
   EXPECT_TRUE(changes2()->empty());
 }
 
 // Verifies HierarchyChanged is correctly sent for various adds/removes.
 TEST_F(WindowTreeAppTest, WindowHierarchyChangedWindows) {
+  // Create the embed point now so that the ids line up.
+  Id window_1_1 = ws_client1()->NewWindow(1);
   // 1,2->1,11.
   Id window_1_2 = ws_client1()->NewWindow(2);
   ASSERT_TRUE(window_1_2);
   ASSERT_TRUE(ws_client1()->SetWindowVisibility(window_1_2, true));
   Id window_1_11 = ws_client1()->NewWindow(11);
   ASSERT_TRUE(window_1_11);
   ASSERT_TRUE(ws_client1()->SetWindowVisibility(window_1_11, true));
   ASSERT_TRUE(ws_client1()->AddWindow(window_1_2, window_1_11));
 
-  Id window_1_1 = BuildWindowId(connection_id_1(), 1);
-  ASSERT_NO_FATAL_FAILURE(EstablishSecondConnection(true));
+  ASSERT_NO_FATAL_FAILURE(EstablishSecondConnection(false));
   ASSERT_TRUE(ws_client1()->SetWindowVisibility(window_1_1, true));
 
   ASSERT_TRUE(ws_client2()->WaitForAllMessages());
   changes2()->clear();
 
   // 1,1->1,2->1,11
   {
     // Client 2 should not get anything (1,2 is from another connection).
     ASSERT_TRUE(ws_client1()->AddWindow(window_1_1, window_1_2));
     ASSERT_TRUE(ws_client2()->WaitForAllMessages());
@@ skipping 62 matching lines @@
   ASSERT_TRUE(ws_client1()->AddWindow(root_window_id(), window_1_1));
   ASSERT_TRUE(ws_client2()->AddWindow(window_1_1, window_2_11));
   ASSERT_TRUE(ws_client2()->AddWindow(window_2_2, window_2_21));
 
   // Remove 11, should result in a hierarchy change for the root.
   {
     changes1()->clear();
     ASSERT_TRUE(ws_client2()->RemoveWindowFromParent(window_2_11));
 
     ws_client1_->WaitForChangeCount(1);
-    EXPECT_EQ("HierarchyChanged window=" + IdToString(window_2_11) +
-                  " new_parent=null old_parent=" + IdToString(window_1_1),
+    // 2,1 should be IdToString(window_2_11), but window_2_11 is in the id
+    // space of client2, not client1.
+    EXPECT_EQ("HierarchyChanged window=2,1 new_parent=null old_parent=" +
+                  IdToString(window_1_1),
               SingleChangeToDescription(*changes1()));
   }
 
   // Add 2 to 1.
   {
     changes1()->clear();
     ASSERT_TRUE(ws_client2()->AddWindow(window_1_1, window_2_2));
     ws_client1_->WaitForChangeCount(1);
     EXPECT_EQ("HierarchyChanged window=" + IdToString(window_2_2) +
                   " new_parent=" + IdToString(window_1_1) + " old_parent=null",
               SingleChangeToDescription(*changes1()));
-    EXPECT_EQ("[" + WindowParentToString(window_2_2, window_1_1) + "],[" +
-                  WindowParentToString(window_2_21, window_2_2) + "]",
+    // "window=2,3 parent=2,2]" should be,
+    // WindowParentToString(window_2_21, window_2_2), but isn't because of
+    // differing id spaces.
+    EXPECT_EQ("[" + WindowParentToString(window_2_2, window_1_1) +
+                  "],[window=2,3 parent=2,2]",
               ChangeWindowDescription(*changes1()));
   }
 }
 
 TEST_F(WindowTreeAppTest, ReorderWindow) {
   ASSERT_NO_FATAL_FAILURE(EstablishSecondConnection(true));
 
   Id window_2_1 = ws_client2()->NewWindow(1);
   Id window_2_2 = ws_client2()->NewWindow(2);
   Id window_2_3 = ws_client2()->NewWindow(3);
   Id window_1_4 = ws_client1()->NewWindow(4);  // Peer to 1,1
   Id window_1_5 = ws_client1()->NewWindow(5);  // Peer to 1,1
   Id window_2_6 = ws_client2()->NewWindow(6);  // Child of 1,2.
   Id window_2_7 = ws_client2()->NewWindow(7);  // Unparented.
   Id window_2_8 = ws_client2()->NewWindow(8);  // Unparented.
   ASSERT_TRUE(window_2_1);
   ASSERT_TRUE(window_2_2);
   ASSERT_TRUE(window_2_3);
   ASSERT_TRUE(window_1_4);
   ASSERT_TRUE(window_1_5);
   ASSERT_TRUE(window_2_6);
   ASSERT_TRUE(window_2_7);
   ASSERT_TRUE(window_2_8);
 
   ASSERT_TRUE(ws_client2()->AddWindow(window_2_1, window_2_2));
   ASSERT_TRUE(ws_client2()->AddWindow(window_2_2, window_2_6));
   ASSERT_TRUE(ws_client2()->AddWindow(window_2_1, window_2_3));
   ASSERT_TRUE(ws_client1()->AddWindow(root_window_id(), window_1_4));
   ASSERT_TRUE(ws_client1()->AddWindow(root_window_id(), window_1_5));
-  ASSERT_TRUE(ws_client1()->AddWindow(root_window_id(), window_2_1));
+  ASSERT_TRUE(
+      ws_client2()->AddWindow(BuildWindowId(connection_id_1(), 1), window_2_1));
 
   {
     changes1()->clear();
     ASSERT_TRUE(ws_client2()->ReorderWindow(window_2_2, window_2_3,
                                             mojom::OrderDirection::ABOVE));
 
     ws_client1_->WaitForChangeCount(1);
     EXPECT_EQ("Reordered window=" + IdToString(window_2_2) + " relative=" +
                   IdToString(window_2_3) + " direction=above",
               SingleChangeToDescription(*changes1()));
@@ skipping 29 matching lines @@
 
   // view7 & view8 are un-parented.
   EXPECT_FALSE(ws_client1()->ReorderWindow(window_2_7, window_2_8,
                                            mojom::OrderDirection::ABOVE));
 }
 
 // Verifies DeleteWindow works.
 TEST_F(WindowTreeAppTest, DeleteWindow) {
   ASSERT_NO_FATAL_FAILURE(EstablishSecondConnection(true));
   Id window_1_1 = BuildWindowId(connection_id_1(), 1);
-  Id window_2_2 = ws_client2()->NewWindow(2);
-  ASSERT_TRUE(window_2_2);
+  Id window_2_1 = ws_client2()->NewWindow(1);
+  ASSERT_TRUE(window_2_1);
 
   // Make 2 a child of 1.
   {
     changes1()->clear();
-    ASSERT_TRUE(ws_client2()->AddWindow(window_1_1, window_2_2));
+    ASSERT_TRUE(ws_client2()->AddWindow(window_1_1, window_2_1));
     ws_client1_->WaitForChangeCount(1);
-    EXPECT_EQ("HierarchyChanged window=" + IdToString(window_2_2) +
+    EXPECT_EQ("HierarchyChanged window=" + IdToString(window_2_1) +
                   " new_parent=" + IdToString(window_1_1) + " old_parent=null",
               SingleChangeToDescription(*changes1()));
   }
 
   // Delete 2.
   {
     changes1()->clear();
     changes2()->clear();
-    ASSERT_TRUE(ws_client2()->DeleteWindow(window_2_2));
+    ASSERT_TRUE(ws_client2()->DeleteWindow(window_2_1));
     EXPECT_TRUE(changes2()->empty());
 
     ws_client1_->WaitForChangeCount(1);
-    EXPECT_EQ("WindowDeleted window=" + IdToString(window_2_2),
+    EXPECT_EQ("WindowDeleted window=" + IdToString(window_2_1),
               SingleChangeToDescription(*changes1()));
   }
 }
 
 // Verifies DeleteWindow isn't allowed from a separate connection.
 TEST_F(WindowTreeAppTest, DeleteWindowFromAnotherConnectionDisallowed) {
   ASSERT_NO_FATAL_FAILURE(EstablishSecondConnection(true));
   EXPECT_FALSE(ws_client2()->DeleteWindow(BuildWindowId(connection_id_1(), 1)));
 }
 
 // Verifies if a window was deleted and then reused that other clients are
 // properly notified.
 TEST_F(WindowTreeAppTest, ReuseDeletedWindowId) {
   ASSERT_NO_FATAL_FAILURE(EstablishSecondConnection(true));
   Id window_1_1 = BuildWindowId(connection_id_1(), 1);
-  Id window_2_2 = ws_client2()->NewWindow(2);
-  ASSERT_TRUE(window_2_2);
+  Id window_2_1 = ws_client2()->NewWindow(1);
+  ASSERT_TRUE(window_2_1);
 
   // Add 2 to 1.
   {
     changes1()->clear();
-    ASSERT_TRUE(ws_client2()->AddWindow(window_1_1, window_2_2));
+    ASSERT_TRUE(ws_client2()->AddWindow(window_1_1, window_2_1));
     ws_client1_->WaitForChangeCount(1);
-    EXPECT_EQ("HierarchyChanged window=" + IdToString(window_2_2) +
+    EXPECT_EQ("HierarchyChanged window=" + IdToString(window_2_1) +
                   " new_parent=" + IdToString(window_1_1) + " old_parent=null",
               SingleChangeToDescription(*changes1()));
-    EXPECT_EQ("[" + WindowParentToString(window_2_2, window_1_1) + "]",
+    EXPECT_EQ("[" + WindowParentToString(window_2_1, window_1_1) + "]",
               ChangeWindowDescription(*changes1()));
   }
 
   // Delete 2.
   {
     changes1()->clear();
-    ASSERT_TRUE(ws_client2()->DeleteWindow(window_2_2));
+    ASSERT_TRUE(ws_client2()->DeleteWindow(window_2_1));
 
     ws_client1_->WaitForChangeCount(1);
-    EXPECT_EQ("WindowDeleted window=" + IdToString(window_2_2),
+    EXPECT_EQ("WindowDeleted window=" + IdToString(window_2_1),
               SingleChangeToDescription(*changes1()));
   }
 
   // Create 2 again, and add it back to 1. Should get the same notification.
-  window_2_2 = ws_client2()->NewWindow(2);
-  ASSERT_TRUE(window_2_2);
+  window_2_1 = ws_client2()->NewWindow(2);
+  ASSERT_TRUE(window_2_1);
   {
     changes1()->clear();
-    ASSERT_TRUE(ws_client2()->AddWindow(window_1_1, window_2_2));
+    ASSERT_TRUE(ws_client2()->AddWindow(window_1_1, window_2_1));
 
     ws_client1_->WaitForChangeCount(1);
-    EXPECT_EQ("HierarchyChanged window=" + IdToString(window_2_2) +
+    EXPECT_EQ("HierarchyChanged window=" + IdToString(window_2_1) +
                   " new_parent=" + IdToString(window_1_1) + " old_parent=null",
               SingleChangeToDescription(*changes1()));
-    EXPECT_EQ("[" + WindowParentToString(window_2_2, window_1_1) + "]",
+    EXPECT_EQ("[" + WindowParentToString(window_2_1, window_1_1) + "]",
               ChangeWindowDescription(*changes1()));
   }
 }
 
 // Assertions for GetWindowTree.
 TEST_F(WindowTreeAppTest, GetWindowTree) {
   ASSERT_NO_FATAL_FAILURE(EstablishSecondConnection(true));
   Id window_1_1 = BuildWindowId(connection_id_1(), 1);
 
   // Create 11 in first connection and make it a child of 1.
   Id window_1_11 = ws_client1()->NewWindow(11);
   ASSERT_TRUE(window_1_11);
   ASSERT_TRUE(ws_client1()->AddWindow(root_window_id(), window_1_1));
   ASSERT_TRUE(ws_client1()->AddWindow(window_1_1, window_1_11));
 
   // Create two windows in second connection, 2 and 3, both children of 1.
+  Id window_2_1 = ws_client2()->NewWindow(1);
   Id window_2_2 = ws_client2()->NewWindow(2);
-  Id window_2_3 = ws_client2()->NewWindow(3);
+  ASSERT_TRUE(window_2_1);
   ASSERT_TRUE(window_2_2);
-  ASSERT_TRUE(window_2_3);
+  ASSERT_TRUE(ws_client2()->AddWindow(window_1_1, window_2_1));
   ASSERT_TRUE(ws_client2()->AddWindow(window_1_1, window_2_2));
-  ASSERT_TRUE(ws_client2()->AddWindow(window_1_1, window_2_3));
 
   // Verifies GetWindowTree() on the root. The root connection sees all.
   {
     std::vector<TestWindow> windows;
     GetWindowTree(ws1(), root_window_id(), &windows);
     ASSERT_EQ(5u, windows.size());
     EXPECT_EQ(WindowParentToString(root_window_id(), kNullParentId),
               windows[0].ToString());
     EXPECT_EQ(WindowParentToString(window_1_1, root_window_id()),
               windows[1].ToString());
     EXPECT_EQ(WindowParentToString(window_1_11, window_1_1),
               windows[2].ToString());
+    EXPECT_EQ(WindowParentToString(window_2_1, window_1_1),
+              windows[3].ToString());
     EXPECT_EQ(WindowParentToString(window_2_2, window_1_1),
-              windows[3].ToString());
-    EXPECT_EQ(WindowParentToString(window_2_3, window_1_1),
               windows[4].ToString());
   }
 
   // Verifies GetWindowTree() on the window 1,1 from ws2(). ws2() sees 1,1 as
   // 1,1
   // is ws2()'s root and ws2() sees all the windows it created.
   {
     std::vector<TestWindow> windows;
     GetWindowTree(ws2(), window_1_1, &windows);
     ASSERT_EQ(3u, windows.size());
     EXPECT_EQ(WindowParentToString(window_1_1, kNullParentId),
               windows[0].ToString());
+    EXPECT_EQ(WindowParentToString(window_2_1, window_1_1),
+              windows[1].ToString());
     EXPECT_EQ(WindowParentToString(window_2_2, window_1_1),
-              windows[1].ToString());
-    EXPECT_EQ(WindowParentToString(window_2_3, window_1_1),
               windows[2].ToString());
   }
 
   // Connection 2 shouldn't be able to get the root tree.
   {
     std::vector<TestWindow> windows;
     GetWindowTree(ws2(), root_window_id(), &windows);
     ASSERT_EQ(0u, windows.size());
   }
 }
 
 TEST_F(WindowTreeAppTest, SetWindowBounds) {
   Id window_1_1 = ws_client1()->NewWindow(1);
   ASSERT_TRUE(window_1_1);
   ASSERT_TRUE(ws_client1()->AddWindow(root_window_id(), window_1_1));
 
   ASSERT_NO_FATAL_FAILURE(EstablishSecondConnection(false));
 
   changes2()->clear();
 
+  ws_client2_->set_track_root_bounds_changes(true);
+
   ws1()->SetWindowBounds(10, window_1_1,
                          mojo::Rect::From(gfx::Rect(0, 0, 100, 100)));
   ASSERT_TRUE(ws_client1()->WaitForChangeCompleted(10));
 
   ws_client2_->WaitForChangeCount(1);
   EXPECT_EQ("BoundsChanged window=" + IdToString(window_1_1) +
                 " old_bounds=0,0 0x0 new_bounds=0,0 100x100",
             SingleChangeToDescription(*changes2()));
 
   // Should not be possible to change the bounds of a window created by another
@@ skipping 290 matching lines @@
   Id window_1_2 = ws_client1()->NewWindow(2);
   ASSERT_TRUE(window_1_2);
   ASSERT_TRUE(ws_client1()->SetWindowVisibility(window_1_2, true));
   ASSERT_TRUE(ws_client1()->AddWindow(root_window_id(), window_1_1));
   ASSERT_TRUE(ws_client1()->AddWindow(window_1_1, window_1_2));
 
   // Establish the second connection at 1,2.
   ASSERT_NO_FATAL_FAILURE(EstablishSecondConnectionWithRoot(window_1_2));
 
   // Add 2,3 as a child of 1,2.
-  Id window_2_3 = ws_client2()->NewWindow(3);
-  ASSERT_TRUE(window_2_3);
-  ASSERT_TRUE(ws_client2()->SetWindowVisibility(window_2_3, true));
-  ASSERT_TRUE(ws_client2()->AddWindow(window_1_2, window_2_3));
+  Id window_2_1 = ws_client2()->NewWindow(1);
+  ASSERT_TRUE(window_2_1);
+  ASSERT_TRUE(ws_client2()->SetWindowVisibility(window_2_1, true));
+  ASSERT_TRUE(ws_client2()->AddWindow(window_1_2, window_2_1));
   ASSERT_TRUE(ws_client1()->WaitForAllMessages());
 
   changes2()->clear();
   // Hide 1,2 from connection 1. Connection 2 should see this.
   ASSERT_TRUE(ws_client1()->SetWindowVisibility(window_1_2, false));
   {
     ws_client2_->WaitForChangeCount(1);
     EXPECT_EQ(
         "VisibilityChanged window=" + IdToString(window_1_2) + " visible=false",
         SingleChangeToDescription(*changes2()));
@@ skipping 24 matching lines @@
   ASSERT_TRUE(ws_client1()->SetWindowVisibility(window_1_1, true));
   {
     ws_client2_->WaitForChangeCount(1);
     EXPECT_EQ(
         "DrawnStateChanged window=" + IdToString(window_1_2) + " drawn=true",
         SingleChangeToDescription(*changes2()));
   }
 
   // Change visibility of 2,3, connection 1 should see this.
   changes1()->clear();
-  ASSERT_TRUE(ws_client2()->SetWindowVisibility(window_2_3, false));
+  ASSERT_TRUE(ws_client2()->SetWindowVisibility(window_2_1, false));
   {
     ws_client1_->WaitForChangeCount(1);
     EXPECT_EQ(
-        "VisibilityChanged window=" + IdToString(window_2_3) + " visible=false",
+        "VisibilityChanged window=" + IdToString(window_2_1) + " visible=false",
         SingleChangeToDescription(*changes1()));
   }
 
   changes2()->clear();
   // Remove 1,1 from the root, connection 2 should see drawn state changed.
   ASSERT_TRUE(ws_client1()->RemoveWindowFromParent(window_1_1));
   {
     ws_client2_->WaitForChangeCount(1);
     EXPECT_EQ(
         "DrawnStateChanged window=" + IdToString(window_1_2) + " drawn=false",
@@ skipping 56 matching lines @@
     EXPECT_EQ("PropertyChanged window=" + IdToString(window_1_1) +
                   " key=one value=NULL",
               SingleChangeToDescription(*changes2()));
   }
 }
 
 TEST_F(WindowTreeAppTest, OnEmbeddedAppDisconnected) {
   // Create connection 2 and 3.
   ASSERT_NO_FATAL_FAILURE(EstablishSecondConnection(true));
   Id window_1_1 = BuildWindowId(connection_id_1(), 1);
-  Id window_2_2 = ws_client2()->NewWindow(2);
-  ASSERT_TRUE(window_2_2);
-  ASSERT_TRUE(ws_client2()->AddWindow(window_1_1, window_2_2));
+  Id window_2_1 = ws_client2()->NewWindow(1);
+  ASSERT_TRUE(window_2_1);
+  ASSERT_TRUE(ws_client2()->AddWindow(window_1_1, window_2_1));
   changes2()->clear();
-  ASSERT_NO_FATAL_FAILURE(EstablishThirdConnection(ws2(), window_2_2));
+  ASSERT_NO_FATAL_FAILURE(EstablishThirdConnection(ws2(), window_2_1));
 
-  // Connection 1 should get a hierarchy change for window_2_2.
+  // Connection 1 should get a hierarchy change for window_2_1.
   ws_client1_->WaitForChangeCount(1);
   changes1()->clear();
 
   // Close connection 3. Connection 2 (which had previously embedded 3) should
   // be notified of this.
   ws_client3_.reset();
   ws_client2_->WaitForChangeCount(1);
-  EXPECT_EQ("OnEmbeddedAppDisconnected window=" + IdToString(window_2_2),
+  EXPECT_EQ("OnEmbeddedAppDisconnected window=" + IdToString(window_2_1),
             SingleChangeToDescription(*changes2()));
 
   ws_client1_->WaitForChangeCount(1);
-  EXPECT_EQ("OnEmbeddedAppDisconnected window=" + IdToString(window_2_2),
+  EXPECT_EQ("OnEmbeddedAppDisconnected window=" + IdToString(window_2_1),
             SingleChangeToDescription(*changes1()));
 }
 
 // Verifies when the parent of an Embed() is destroyed the embedded app gets
 // a WindowDeleted (and doesn't trigger a DCHECK).
 TEST_F(WindowTreeAppTest, OnParentOfEmbedDisconnects) {
   // Create connection 2 and 3.
   ASSERT_NO_FATAL_FAILURE(EstablishSecondConnection(true));
   Id window_1_1 = BuildWindowId(connection_id_1(), 1);
   ASSERT_TRUE(ws_client1()->AddWindow(root_window_id(), window_1_1));
+  Id window_2_1 = ws_client2()->NewWindow(1);
   Id window_2_2 = ws_client2()->NewWindow(2);
-  Id window_2_3 = ws_client2()->NewWindow(3);
+  ASSERT_TRUE(window_2_1);
   ASSERT_TRUE(window_2_2);
-  ASSERT_TRUE(window_2_3);
-  ASSERT_TRUE(ws_client2()->AddWindow(window_1_1, window_2_2));
-  ASSERT_TRUE(ws_client2()->AddWindow(window_2_2, window_2_3));
+  ASSERT_TRUE(ws_client2()->AddWindow(window_1_1, window_2_1));
+  ASSERT_TRUE(ws_client2()->AddWindow(window_2_1, window_2_2));
   changes2()->clear();
-  ASSERT_NO_FATAL_FAILURE(EstablishThirdConnection(ws2(), window_2_3));
+  ASSERT_NO_FATAL_FAILURE(EstablishThirdConnection(ws2(), window_2_2));
   changes3()->clear();
 
   // Close connection 2. Connection 3 should get a delete (for its root).
   ws_client2_.reset();
   ws_client3_->WaitForChangeCount(1);
-  EXPECT_EQ("WindowDeleted window=" + IdToString(window_2_3),
+  EXPECT_EQ("WindowDeleted window=" + IdToString(window_2_2),
             SingleChangeToDescription(*changes3()));
 }
 
 // Verifies WindowTreeImpl doesn't incorrectly erase from its internal
 // map when a window from another connection with the same window_id is removed.
 TEST_F(WindowTreeAppTest, DontCleanMapOnDestroy) {
   ASSERT_NO_FATAL_FAILURE(EstablishSecondConnection(true));
   Id window_1_1 = BuildWindowId(connection_id_1(), 1);
   ASSERT_TRUE(ws_client2()->NewWindow(1));
   changes1()->clear();
@@ skipping 17 matching lines @@
                     std::move(client2_ptr)));
   client2.WaitForOnEmbed();
   EXPECT_EQ("OnEmbed",
             SingleChangeToDescription(*client2.tracker()->changes()));
 }
 
 TEST_F(WindowTreeAppTest, EmbedFailsFromOtherConnection) {
   ASSERT_NO_FATAL_FAILURE(EstablishSecondConnection(true));
 
   Id window_1_1 = BuildWindowId(connection_id_1(), 1);
-  Id window_2_2 = ws_client2()->NewWindow(2);
-  ASSERT_TRUE(window_2_2);
-  ASSERT_TRUE(ws_client2()->AddWindow(window_1_1, window_2_2));
-  ASSERT_NO_FATAL_FAILURE(EstablishThirdConnection(ws2(), window_2_2));
+  Id window_2_1 = ws_client2()->NewWindow(1);
+  ASSERT_TRUE(window_2_1);
+  ASSERT_TRUE(ws_client2()->AddWindow(window_1_1, window_2_1));
+  ASSERT_NO_FATAL_FAILURE(EstablishThirdConnection(ws2(), window_2_1));
 
   Id window_3_3 = ws_client3()->NewWindow(3);
   ASSERT_TRUE(window_3_3);
-  ASSERT_TRUE(ws_client3()->AddWindow(window_2_2, window_3_3));
+  ASSERT_TRUE(ws_client3()->AddWindow(window_2_1, window_3_3));
 
   // 2 should not be able to embed in window_3_3 as window_3_3 was not created
   // by
   // 2.
   EXPECT_FALSE(EmbedUrl(application_impl(), ws2(), application_impl()->url(),
                         window_3_3));
 }
 
 // Verifies Embed() from window manager on another connections window works.
 TEST_F(WindowTreeAppTest, EmbedFromOtherConnection) {
   ASSERT_NO_FATAL_FAILURE(EstablishSecondConnection(true));
 
   Id window_1_1 = BuildWindowId(connection_id_1(), 1);
-  Id window_2_2 = ws_client2()->NewWindow(2);
-  ASSERT_TRUE(window_2_2);
-  ASSERT_TRUE(ws_client2()->AddWindow(window_1_1, window_2_2));
+  Id window_2_1 = ws_client2()->NewWindow(1);
+  ASSERT_TRUE(window_2_1);
+  ASSERT_TRUE(ws_client2()->AddWindow(window_1_1, window_2_1));
 
   changes2()->clear();
 
-  // Establish a third connection in window_2_2.
-  ASSERT_NO_FATAL_FAILURE(EstablishThirdConnection(ws1(), window_2_2));
+  // Establish a third connection in window_2_1.
+  ASSERT_NO_FATAL_FAILURE(EstablishThirdConnection(ws1(), window_2_1));
 
   ASSERT_TRUE(ws_client2()->WaitForAllMessages());
   EXPECT_EQ(std::string(), SingleChangeToDescription(*changes2()));
 }
 
 TEST_F(WindowTreeAppTest, CantEmbedFromConnectionRoot) {
   // Shouldn't be able to embed into the root.
   ASSERT_FALSE(EmbedUrl(application_impl(), ws1(), application_impl()->url(),
                         root_window_id()));
 
@@ skipping 11 matching lines @@
   WaitForWindowTreeClient();
 
   Id window_1_2 = ws_client1()->NewWindow(2);
   ASSERT_TRUE(window_1_2);
   ASSERT_TRUE(
       ws_client1()->AddWindow(BuildWindowId(connection_id_1(), 1), window_1_2));
   ASSERT_TRUE(ws_client3_.get() == nullptr);
   ws_client3_ = EstablishConnectionViaEmbedWithPolicyBitmask(
       ws1(), window_1_2, mojom::WindowTree::kAccessPolicyEmbedRoot, nullptr);
   ASSERT_TRUE(ws_client3_.get() != nullptr);
-  ws_client3_->set_root_window(root_window_id());
 
   // window_1_2 is ws3's root, so even though v3 is an embed root it should not
   // be able to Embed into itself.
   ASSERT_FALSE(EmbedUrl(application_impl(), ws3(), application_impl()->url(),
                         window_1_2));
 }
 
 // Verifies that a transient window tracks its parent's lifetime.
 TEST_F(WindowTreeAppTest, TransientWindowTracksTransientParentLifetime) {
   ASSERT_NO_FATAL_FAILURE(EstablishSecondConnection(true));
@@ skipping 33 matching lines @@
 
   changes1()->clear();
   ASSERT_TRUE(ws_client2()->DeleteWindow(window_2_1));
   ws_client1()->WaitForChangeCount(2);
   EXPECT_EQ("WindowDeleted window=" + IdToString(window_2_2),
             ChangesToDescription1(*changes1())[0]);
   EXPECT_EQ("WindowDeleted window=" + IdToString(window_2_1),
             ChangesToDescription1(*changes1())[1]);
 }
 
+TEST_F(WindowTreeAppTest, Ids) {
+  const Id window_1_100 = ws_client1()->NewWindow(100);
+  ASSERT_TRUE(window_1_100);
+  ASSERT_TRUE(ws_client1()->AddWindow(root_window_id(), window_1_100));
+
+  // Establish the second connection at 1,100.
+  ASSERT_NO_FATAL_FAILURE(EstablishSecondConnectionWithRoot(window_1_100));
+
+  // 1,100 is the id in the ws_client1's id space. The new client should see
+  // 2,1 (the server id).
+  const Id window_1_100_in_ws2 = BuildWindowId(connection_id_1(), 1);
+  EXPECT_EQ(window_1_100_in_ws2, ws_client2()->root_window_id());
+
+  // The first window created in the second connection gets a server id of 2,1
+  // regardless of the id the client uses.
+  const Id window_2_101 = ws_client2()->NewWindow(101);
+  ASSERT_TRUE(ws_client2()->AddWindow(window_1_100_in_ws2, window_2_101));
+  const Id window_2_101_in_ws1 = BuildWindowId(connection_id_2(), 1);
+  ws_client1()->WaitForChangeCount(1);
+  EXPECT_EQ("HierarchyChanged window=" + IdToString(window_2_101_in_ws1) +
+                " new_parent=" + IdToString(window_1_100) + " old_parent=null",
+            SingleChangeToDescription(*changes1()));
+  changes1()->clear();
+
+  // Change the bounds of window_2_101 and make sure server gets it.
+  ws2()->SetWindowBounds(11, window_2_101,
+                         mojo::Rect::From(gfx::Rect(1, 2, 3, 4)));
+  ASSERT_TRUE(ws_client2()->WaitForChangeCompleted(11));
+  ws_client1()->WaitForChangeCount(1);
+  EXPECT_EQ("BoundsChanged window=" + IdToString(window_2_101_in_ws1) +
+                " old_bounds=0,0 0x0 new_bounds=1,2 3x4",
+            SingleChangeToDescription(*changes1()));
+  changes2()->clear();
+
+  // Remove 2_101 from wm, client1 should see the change.
+  ws1()->RemoveWindowFromParent(12, window_2_101_in_ws1);
+  ASSERT_TRUE(ws_client1()->WaitForChangeCompleted(12));
+  ws_client2()->WaitForChangeCount(1);
+  EXPECT_EQ("HierarchyChanged window=" + IdToString(window_2_101) +
+                " new_parent=null old_parent=" +
+                IdToString(window_1_100_in_ws2),
+            SingleChangeToDescription(*changes2()));
+}
+
 // TODO(sky): need to better track changes to initial connection. For example,
 // that SetBounsdWindows/AddWindow and the like don't result in messages to the
 // originating connection.
 
 // TODO(sky): make sure coverage of what was
 // WindowManagerTest.SecondEmbedRoot_InitService and
 // WindowManagerTest.MultipleEmbedRootsBeforeWTHReady gets added to window
 // manager
 // tests.
 
 }  // namespace ws
 }  // namespace mus