Makes it so a node can only the root of one connection at a time

mojo/services/view_manager/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 <string>
 #include <vector>
 
 #include "base/at_exit.h"
 #include "base/auto_reset.h"
 #include "base/bind.h"
@@ skipping 19 matching lines @@
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/gfx/geometry/rect.h"
 
 namespace mojo {
 namespace view_manager {
 namespace service {
 
 namespace {
 
 const char kTestServiceURL[] = "mojo:test_url";
+const char kTestServiceURL2[] = "mojo:test_url2";
 
 // ViewManagerProxy is a proxy to an ViewManagerService. It handles invoking
 // ViewManagerService functions on the right thread in a synchronous manner
 // (each ViewManagerService cover function blocks until the response from the
 // ViewManagerService is returned). In addition it tracks the set of
 // ViewManagerClient messages received by way of a vector of Changes. Use
 // DoRunLoopUntilChangesCount() to wait for a certain number of messages to be
 // received.
 class ViewManagerProxy : public TestChangeTracker::Delegate {
  public:
@@ skipping 32 matching lines @@
     return changes_;
   }
 
   const std::vector<Change>& changes() const { return changes_; }
 
   // Destroys the connection, blocking until done.
   void Destroy() {
     router_->CloseMessagePipe();
   }
 
+  void ClearChanges() {
+    changes_.clear();
+    tracker_->changes()->clear();
+  }
+
   // The following functions are cover methods for ViewManagerService. They
   // block until the result is received.
   bool CreateNode(Id node_id) {
     changes_.clear();
     ErrorCode result = ERROR_CODE_NONE;
     view_manager_->CreateNode(
         node_id,
         base::Bind(&ViewManagerProxy::GotResultWithErrorCode,
                    base::Unretained(this), &result));
     RunMainLoop();
@@ skipping 58 matching lines @@
     RunMainLoop();
     return result;
   }
   void GetNodeTree(Id node_id, std::vector<TestNode>* nodes) {
     changes_.clear();
     view_manager_->GetNodeTree(node_id,
                                base::Bind(&ViewManagerProxy::GotNodeTree,
                                           base::Unretained(this), nodes));
     RunMainLoop();
   }
-  bool Embed(const Id node_id) {
+  bool Embed(const Id node_id, const char* url) {
     changes_.clear();
     base::AutoReset<bool> auto_reset(&in_embed_, true);
     bool result = false;
-    view_manager_->Embed(kTestServiceURL, node_id,
+    view_manager_->Embed(url, node_id,
                          base::Bind(&ViewManagerProxy::GotResult,
                                     base::Unretained(this), &result));
     RunMainLoop();
     return result;
   }
   bool DeleteNode(Id node_id, Id server_change_id) {
     changes_.clear();
     bool result = false;
     view_manager_->DeleteNode(node_id,
                               server_change_id,
@@ skipping 268 matching lines @@
  public:
   ViewManagerTest() : connection_(NULL), connection2_(NULL) {}
 
   virtual void SetUp() OVERRIDE {
     test_helper_.Init();
 
     test_helper_.SetLoaderForURL(
         scoped_ptr<ServiceLoader>(new EmbedServiceLoader()),
         GURL(kTestServiceURL));
 
+    test_helper_.SetLoaderForURL(
+        scoped_ptr<ServiceLoader>(new EmbedServiceLoader()),
+        GURL(kTestServiceURL2));
+
     test_helper_.service_manager()->ConnectToService(
         GURL("mojo:mojo_view_manager"),
         &view_manager_init_);
     ASSERT_TRUE(EmbedRoot(view_manager_init_.get(), kTestServiceURL));
 
     connection_ = ViewManagerProxy::WaitForInstance();
     ASSERT_TRUE(connection_ != NULL);
     connection_->DoRunLoopUntilChangesCount(1);
   }
 
   virtual void TearDown() OVERRIDE {
     if (connection2_)
       connection2_->Destroy();
     if (connection_)
       connection_->Destroy();
   }
 
  protected:
   void EstablishSecondConnectionWithRoot(Id root_id) {
-    ASSERT_TRUE(connection_->Embed(root_id));
+    ASSERT_TRUE(connection_->Embed(root_id, kTestServiceURL));
     connection2_ = ViewManagerProxy::WaitForInstance();
     ASSERT_TRUE(connection2_ != NULL);
     connection2_->DoRunLoopUntilChangesCount(1);
     ASSERT_EQ(1u, connection2_->changes().size());
   }
 
   // Creates a second connection to the viewmanager.
   void EstablishSecondConnection(bool create_initial_node) {
     if (create_initial_node)
       ASSERT_TRUE(connection_->CreateNode(BuildNodeId(1, 1)));
@@ skipping 80 matching lines @@
 
 // Verifies hierarchy changes.
 TEST_F(ViewManagerTest, AddRemoveNotify) {
   ASSERT_TRUE(connection_->CreateNode(BuildNodeId(1, 2)));
   ASSERT_TRUE(connection_->CreateNode(BuildNodeId(1, 3)));
 
   ASSERT_NO_FATAL_FAILURE(EstablishSecondConnection(true));
 
   // Make 3 a child of 2.
   {
-    ASSERT_TRUE(connection_->AddNode(BuildNodeId(1, 2), BuildNodeId(1, 3), 1));
-    EXPECT_TRUE(connection_->changes().empty());
-
-    connection2_->DoRunLoopUntilChangesCount(1);
-    const Changes changes(ChangesToDescription1(connection2_->changes()));
-    ASSERT_EQ(1u, changes.size());
-    EXPECT_EQ("ServerChangeIdAdvanced 2", changes[0]);
-  }
-
-  // Remove 3 from its parent.
-  {
-    ASSERT_TRUE(connection_->RemoveNodeFromParent(BuildNodeId(1, 3), 2));
+    ASSERT_TRUE(connection_->AddNode(BuildNodeId(1, 2), BuildNodeId(1, 3), 2));
     EXPECT_TRUE(connection_->changes().empty());
 
     connection2_->DoRunLoopUntilChangesCount(1);
     const Changes changes(ChangesToDescription1(connection2_->changes()));
     ASSERT_EQ(1u, changes.size());
     EXPECT_EQ("ServerChangeIdAdvanced 3", changes[0]);
   }
+
+  // Remove 3 from its parent.
+  {
+    ASSERT_TRUE(connection_->RemoveNodeFromParent(BuildNodeId(1, 3), 3));
+    EXPECT_TRUE(connection_->changes().empty());
+
+    connection2_->DoRunLoopUntilChangesCount(1);
+    const Changes changes(ChangesToDescription1(connection2_->changes()));
+    ASSERT_EQ(1u, changes.size());
+    EXPECT_EQ("ServerChangeIdAdvanced 4", changes[0]);
+  }
 }
 
 // Verifies AddNode fails when node is already in position.
 TEST_F(ViewManagerTest, AddNodeWithNoChange) {
   ASSERT_TRUE(connection_->CreateNode(BuildNodeId(1, 2)));
   ASSERT_TRUE(connection_->CreateNode(BuildNodeId(1, 3)));
 
   ASSERT_NO_FATAL_FAILURE(EstablishSecondConnection(true));
 
   // Make 3 a child of 2.
   {
-    ASSERT_TRUE(connection_->AddNode(BuildNodeId(1, 2), BuildNodeId(1, 3), 1));
+    ASSERT_TRUE(connection_->AddNode(BuildNodeId(1, 2), BuildNodeId(1, 3), 2));
 
     connection2_->DoRunLoopUntilChangesCount(1);
     const Changes changes(ChangesToDescription1(connection2_->changes()));
     ASSERT_EQ(1u, changes.size());
-    EXPECT_EQ("ServerChangeIdAdvanced 2", changes[0]);
+    EXPECT_EQ("ServerChangeIdAdvanced 3", changes[0]);
   }
 
   // Try again, this should fail.
   {
-    EXPECT_FALSE(connection_->AddNode(BuildNodeId(1, 2), BuildNodeId(1, 3), 2));
+    EXPECT_FALSE(connection_->AddNode(BuildNodeId(1, 2), BuildNodeId(1, 3), 3));
   }
 }
 
 // Verifies AddNode fails when node is already in position.
 TEST_F(ViewManagerTest, AddAncestorFails) {
   ASSERT_TRUE(connection_->CreateNode(BuildNodeId(1, 2)));
   ASSERT_TRUE(connection_->CreateNode(BuildNodeId(1, 3)));
 
   ASSERT_NO_FATAL_FAILURE(EstablishSecondConnection(true));
 
   // Make 3 a child of 2.
   {
-    ASSERT_TRUE(connection_->AddNode(BuildNodeId(1, 2), BuildNodeId(1, 3), 1));
+    ASSERT_TRUE(connection_->AddNode(BuildNodeId(1, 2), BuildNodeId(1, 3), 2));
     connection2_->DoRunLoopUntilChangesCount(1);
     const Changes changes(ChangesToDescription1(connection2_->changes()));
     ASSERT_EQ(1u, changes.size());
-    EXPECT_EQ("ServerChangeIdAdvanced 2", changes[0]);
+    EXPECT_EQ("ServerChangeIdAdvanced 3", changes[0]);
   }
 
   // Try to make 2 a child of 3, this should fail since 2 is an ancestor of 3.
   {
-    EXPECT_FALSE(connection_->AddNode(BuildNodeId(1, 3), BuildNodeId(1, 2), 2));
+    EXPECT_FALSE(connection_->AddNode(BuildNodeId(1, 3), BuildNodeId(1, 2), 3));
   }
 }
 
 // Verifies adding with an invalid id fails.
 TEST_F(ViewManagerTest, AddWithInvalidServerId) {
   // Create two nodes.
   ASSERT_TRUE(connection_->CreateNode(BuildNodeId(1, 1)));
   ASSERT_TRUE(connection_->CreateNode(BuildNodeId(1, 2)));
 
   // Make 2 a child of 1. Supply an invalid change id, which should fail.
   ASSERT_FALSE(connection_->AddNode(BuildNodeId(1, 1), BuildNodeId(1, 2), 0));
 }
 
 // Verifies adding to root sends right notifications.
 TEST_F(ViewManagerTest, AddToRoot) {
   ASSERT_TRUE(connection_->CreateNode(BuildNodeId(1, 21)));
   ASSERT_TRUE(connection_->CreateNode(BuildNodeId(1, 3)));
 
   ASSERT_NO_FATAL_FAILURE(EstablishSecondConnection(true));
 
   // Make 3 a child of 21.
   {
-    ASSERT_TRUE(connection_->AddNode(BuildNodeId(1, 21), BuildNodeId(1, 3), 1));
+    ASSERT_TRUE(connection_->AddNode(BuildNodeId(1, 21), BuildNodeId(1, 3), 2));
 
     connection2_->DoRunLoopUntilChangesCount(1);
     const Changes changes(ChangesToDescription1(connection2_->changes()));
     ASSERT_EQ(1u, changes.size());
-    EXPECT_EQ("ServerChangeIdAdvanced 2", changes[0]);
+    EXPECT_EQ("ServerChangeIdAdvanced 3", changes[0]);
   }
 
   // Make 21 a child of 1.
   {
-    ASSERT_TRUE(connection_->AddNode(BuildNodeId(1, 1), BuildNodeId(1, 21), 2));
+    ASSERT_TRUE(connection_->AddNode(BuildNodeId(1, 1), BuildNodeId(1, 21), 3));
 
     connection2_->DoRunLoopUntilChangesCount(1);
     const Changes changes(ChangesToDescription1(connection2_->changes()));
     ASSERT_EQ(1u, changes.size());
     EXPECT_EQ(
-        "HierarchyChanged change_id=2 node=1,21 new_parent=1,1 old_parent=null",
+        "HierarchyChanged change_id=3 node=1,21 new_parent=1,1 old_parent=null",
         changes[0]);
   }
 }
 
 // Verifies HierarchyChanged is correctly sent for various adds/removes.
 TEST_F(ViewManagerTest, NodeHierarchyChangedNodes) {
   ASSERT_TRUE(connection_->CreateNode(BuildNodeId(1, 2)));
   ASSERT_TRUE(connection_->CreateNode(BuildNodeId(1, 11)));
   // Make 11 a child of 2.
   ASSERT_TRUE(connection_->AddNode(BuildNodeId(1, 2), BuildNodeId(1, 11), 1));
 
   ASSERT_NO_FATAL_FAILURE(EstablishSecondConnection(true));
 
   // Make 2 a child of 1.
   {
-    ASSERT_TRUE(connection_->AddNode(BuildNodeId(1, 1), BuildNodeId(1, 2), 2));
+    ASSERT_TRUE(connection_->AddNode(BuildNodeId(1, 1), BuildNodeId(1, 2), 3));
 
     // Client 2 should get a hierarchy change that includes the new nodes as it
     // has not yet seen them.
     connection2_->DoRunLoopUntilChangesCount(1);
     const Changes changes(ChangesToDescription1(connection2_->changes()));
     ASSERT_EQ(1u, changes.size());
     EXPECT_EQ(
-        "HierarchyChanged change_id=2 node=1,2 new_parent=1,1 old_parent=null",
+        "HierarchyChanged change_id=3 node=1,2 new_parent=1,1 old_parent=null",
         changes[0]);
     EXPECT_EQ("[node=1,2 parent=1,1 view=null],"
               "[node=1,11 parent=1,2 view=null]",
               ChangeNodeDescription(connection2_->changes()));
   }
 
   // Add 1 to the root.
   {
-    ASSERT_TRUE(connection_->AddNode(BuildNodeId(0, 1), BuildNodeId(1, 1), 3));
+    ASSERT_TRUE(connection_->AddNode(BuildNodeId(0, 1), BuildNodeId(1, 1), 4));
 
     // Client 2 should get a hierarchy change that includes the new nodes as it
     // has not yet seen them.
     connection2_->DoRunLoopUntilChangesCount(1);
     const Changes changes(ChangesToDescription1(connection2_->changes()));
     ASSERT_EQ(1u, changes.size());
     EXPECT_EQ(
-        "HierarchyChanged change_id=3 node=1,1 new_parent=null old_parent=null",
+        "HierarchyChanged change_id=4 node=1,1 new_parent=null old_parent=null",
         changes[0]);
     EXPECT_EQ(std::string(), ChangeNodeDescription(connection2_->changes()));
   }
 
   // Remove 1 from its parent.
   {
-    ASSERT_TRUE(connection_->RemoveNodeFromParent(BuildNodeId(1, 1), 4));
+    ASSERT_TRUE(connection_->RemoveNodeFromParent(BuildNodeId(1, 1), 5));
     EXPECT_TRUE(connection_->changes().empty());
 
     connection2_->DoRunLoopUntilChangesCount(1);
     const Changes changes(ChangesToDescription1(connection2_->changes()));
     ASSERT_EQ(1u, changes.size());
     EXPECT_EQ(
-        "HierarchyChanged change_id=4 node=1,1 new_parent=null old_parent=null",
+        "HierarchyChanged change_id=5 node=1,1 new_parent=null old_parent=null",
         changes[0]);
   }
 
   // Create another node, 111, parent it to 11.
   ASSERT_TRUE(connection_->CreateNode(BuildNodeId(1, 111)));
   {
     ASSERT_TRUE(connection_->AddNode(BuildNodeId(1, 11), BuildNodeId(1, 111),
-                                     5));
+                                     6));
 
     connection2_->DoRunLoopUntilChangesCount(1);
     const Changes changes(ChangesToDescription1(connection2_->changes()));
     ASSERT_EQ(1u, changes.size());
     EXPECT_EQ(
-        "HierarchyChanged change_id=5 node=1,111 new_parent=1,11 "
+        "HierarchyChanged change_id=6 node=1,111 new_parent=1,11 "
         "old_parent=null", changes[0]);
     EXPECT_EQ("[node=1,111 parent=1,11 view=null]",
               ChangeNodeDescription(connection2_->changes()));
   }
 
   // Reattach 1 to the root.
   {
-    ASSERT_TRUE(connection_->AddNode(BuildNodeId(0, 1), BuildNodeId(1, 1), 6));
+    ASSERT_TRUE(connection_->AddNode(BuildNodeId(0, 1), BuildNodeId(1, 1), 7));
 
     connection2_->DoRunLoopUntilChangesCount(1);
     const Changes changes(ChangesToDescription1(connection2_->changes()));
     ASSERT_EQ(1u, changes.size());
     EXPECT_EQ(
-        "HierarchyChanged change_id=6 node=1,1 new_parent=null old_parent=null",
+        "HierarchyChanged change_id=7 node=1,1 new_parent=null old_parent=null",
         changes[0]);
     EXPECT_EQ(std::string(), ChangeNodeDescription(connection2_->changes()));
   }
 }
 
 TEST_F(ViewManagerTest, NodeHierarchyChangedAddingKnownToUnknown) {
   // Create the following structure: root -> 1 -> 11 and 2->21 (2 has no
   // parent).
   ASSERT_TRUE(connection_->CreateNode(BuildNodeId(1, 1)));
   ASSERT_TRUE(connection_->CreateNode(BuildNodeId(1, 11)));
   ASSERT_TRUE(connection_->CreateNode(BuildNodeId(1, 2)));
   ASSERT_TRUE(connection_->CreateNode(BuildNodeId(1, 21)));
 
   // Set up the hierarchy.
   ASSERT_TRUE(connection_->AddNode(BuildNodeId(0, 1), BuildNodeId(1, 1), 1));
   ASSERT_TRUE(connection_->AddNode(BuildNodeId(1, 1), BuildNodeId(1, 11), 2));
   ASSERT_TRUE(connection_->AddNode(BuildNodeId(1, 2), BuildNodeId(1, 21), 3));
 
   ASSERT_NO_FATAL_FAILURE(EstablishSecondConnection(false));
   {
     EXPECT_EQ("[node=1,1 parent=null view=null],"
               "[node=1,11 parent=1,1 view=null]",
               ChangeNodeDescription(connection2_->changes()));
   }
 
   // Remove 11, should result in a delete (since 11 is no longer in connection
   // 2's root).
   {
-    ASSERT_TRUE(connection_->RemoveNodeFromParent(BuildNodeId(1, 11), 4));
+    ASSERT_TRUE(connection_->RemoveNodeFromParent(BuildNodeId(1, 11), 5));
 
     connection2_->DoRunLoopUntilChangesCount(1);
     const Changes changes(ChangesToDescription1(connection2_->changes()));
     ASSERT_EQ(1u, changes.size());
-    EXPECT_EQ("NodeDeleted change_id=4 node=1,11", changes[0]);
+    EXPECT_EQ("NodeDeleted change_id=5 node=1,11", changes[0]);
   }
 
   // Add 2 to 1.
   {
-    ASSERT_TRUE(connection_->AddNode(BuildNodeId(1, 1), BuildNodeId(1, 2), 5));
+    ASSERT_TRUE(connection_->AddNode(BuildNodeId(1, 1), BuildNodeId(1, 2), 6));
 
     connection2_->DoRunLoopUntilChangesCount(1);
     const Changes changes(ChangesToDescription1(connection2_->changes()));
     ASSERT_EQ(1u, changes.size());
     EXPECT_EQ(
-        "HierarchyChanged change_id=5 node=1,2 new_parent=1,1 old_parent=null",
+        "HierarchyChanged change_id=6 node=1,2 new_parent=1,1 old_parent=null",
         changes[0]);
     EXPECT_EQ("[node=1,2 parent=1,1 view=null],"
               "[node=1,21 parent=1,2 view=null]",
               ChangeNodeDescription(connection2_->changes()));
   }
 }
 
 TEST_F(ViewManagerTest, ReorderNode) {
   Id node1_id = BuildNodeId(1, 1);
   Id node2_id = BuildNodeId(1, 2);
@@ skipping 15 matching lines @@
   ASSERT_TRUE(connection_->AddNode(node2_id, node6_id, 2));
   ASSERT_TRUE(connection_->AddNode(node1_id, node3_id, 3));
   ASSERT_TRUE(connection_->AddNode(
       NodeIdToTransportId(RootNodeId()), node4_id, 4));
   ASSERT_TRUE(connection_->AddNode(
       NodeIdToTransportId(RootNodeId()), node5_id, 5));
 
   ASSERT_NO_FATAL_FAILURE(EstablishSecondConnection(false));
 
   {
-    connection_->ReorderNode(node2_id, node3_id, ORDER_DIRECTION_ABOVE, 6);
+    connection_->ReorderNode(node2_id, node3_id, ORDER_DIRECTION_ABOVE, 7);
 
     connection2_->DoRunLoopUntilChangesCount(1);
     const Changes changes(ChangesToDescription1(connection2_->changes()));
     ASSERT_EQ(1u, changes.size());
     EXPECT_EQ(
-        "Reordered change_id=6 node=1,2 relative=1,3 direction=above",
+        "Reordered change_id=7 node=1,2 relative=1,3 direction=above",
         changes[0]);
   }
 
   {
-    connection_->ReorderNode(node2_id, node3_id, ORDER_DIRECTION_BELOW, 7);
+    connection_->ReorderNode(node2_id, node3_id, ORDER_DIRECTION_BELOW, 8);
 
     connection2_->DoRunLoopUntilChangesCount(1);
     const Changes changes(ChangesToDescription1(connection2_->changes()));
     ASSERT_EQ(1u, changes.size());
     EXPECT_EQ(
-        "Reordered change_id=7 node=1,2 relative=1,3 direction=below",
+        "Reordered change_id=8 node=1,2 relative=1,3 direction=below",
         changes[0]);
   }
 
   {
     // node2 is already below node3.
     EXPECT_FALSE(
-        connection_->ReorderNode(node2_id, node3_id, ORDER_DIRECTION_BELOW, 8));
+        connection_->ReorderNode(node2_id, node3_id, ORDER_DIRECTION_BELOW, 9));
   }
 
   {
     // node4 & 5 are unknown to connection2_.
     EXPECT_FALSE(connection2_->ReorderNode(
-        node4_id, node5_id, ORDER_DIRECTION_ABOVE, 8));
+        node4_id, node5_id, ORDER_DIRECTION_ABOVE, 9));
   }
 
   {
     // node6 & node3 have different parents.
     EXPECT_FALSE(
-        connection_->ReorderNode(node3_id, node6_id, ORDER_DIRECTION_ABOVE, 8));
+        connection_->ReorderNode(node3_id, node6_id, ORDER_DIRECTION_ABOVE, 9));
   }
 
   {
     // Non-existent node-ids
     EXPECT_FALSE(connection_->ReorderNode(
-        BuildNodeId(1, 27), BuildNodeId(1, 28), ORDER_DIRECTION_ABOVE, 8));
+        BuildNodeId(1, 27), BuildNodeId(1, 28), ORDER_DIRECTION_ABOVE, 9));
   }
 
   {
     // node7 & node8 are un-parented.
     EXPECT_FALSE(
-        connection_->ReorderNode(node7_id, node8_id, ORDER_DIRECTION_ABOVE, 8));
+        connection_->ReorderNode(node7_id, node8_id, ORDER_DIRECTION_ABOVE, 9));
   }
 }
 
 // Verifies DeleteNode works.
 TEST_F(ViewManagerTest, DeleteNode) {
   ASSERT_TRUE(connection_->CreateNode(BuildNodeId(1, 2)));
 
   ASSERT_NO_FATAL_FAILURE(EstablishSecondConnection(true));
 
   // Make 2 a child of 1.
   {
-    ASSERT_TRUE(connection_->AddNode(BuildNodeId(1, 1), BuildNodeId(1, 2), 1));
+    ASSERT_TRUE(connection_->AddNode(BuildNodeId(1, 1), BuildNodeId(1, 2), 2));
     connection2_->DoRunLoopUntilChangesCount(1);
     const Changes changes(ChangesToDescription1(connection2_->changes()));
     ASSERT_EQ(1u, changes.size());
-    EXPECT_EQ("HierarchyChanged change_id=1 node=1,2 new_parent=1,1 "
+    EXPECT_EQ("HierarchyChanged change_id=2 node=1,2 new_parent=1,1 "
               "old_parent=null", changes[0]);
   }
 
   // Delete 2.
   {
-    ASSERT_TRUE(connection_->DeleteNode(BuildNodeId(1, 2), 2));
+    ASSERT_TRUE(connection_->DeleteNode(BuildNodeId(1, 2), 3));
     EXPECT_TRUE(connection_->changes().empty());
 
     connection2_->DoRunLoopUntilChangesCount(1);
     const Changes changes(ChangesToDescription1(connection2_->changes()));
     ASSERT_EQ(1u, changes.size());
-    EXPECT_EQ("NodeDeleted change_id=2 node=1,2", changes[0]);
+    EXPECT_EQ("NodeDeleted change_id=3 node=1,2", changes[0]);
   }
 }
 
 // Verifies DeleteNode isn't allowed from a separate connection.
 TEST_F(ViewManagerTest, DeleteNodeFromAnotherConnectionDisallowed) {
   ASSERT_NO_FATAL_FAILURE(EstablishSecondConnection(true));
   EXPECT_FALSE(connection2_->DeleteNode(BuildNodeId(1, 1), 1));
 }
 
 // Verifies DeleteView isn't allowed from a separate connection.
 TEST_F(ViewManagerTest, DeleteViewFromAnotherConnectionDisallowed) {
   ASSERT_TRUE(connection_->CreateView(BuildViewId(1, 1)));
   ASSERT_NO_FATAL_FAILURE(EstablishSecondConnection(true));
   EXPECT_FALSE(connection2_->DeleteView(BuildViewId(1, 1)));
 }
 
 // Verifies if a node was deleted and then reused that other clients are
 // properly notified.
 TEST_F(ViewManagerTest, ReuseDeletedNodeId) {
   ASSERT_NO_FATAL_FAILURE(EstablishSecondConnection(true));
   ASSERT_TRUE(connection_->CreateNode(BuildNodeId(1, 2)));
 
   // Add 2 to 1.
   {
-    ASSERT_TRUE(connection_->AddNode(BuildNodeId(1, 1), BuildNodeId(1, 2), 1));
+    ASSERT_TRUE(connection_->AddNode(BuildNodeId(1, 1), BuildNodeId(1, 2), 2));
 
     connection2_->DoRunLoopUntilChangesCount(1);
     const Changes changes(ChangesToDescription1(connection2_->changes()));
     EXPECT_EQ(
-        "HierarchyChanged change_id=1 node=1,2 new_parent=1,1 old_parent=null",
+        "HierarchyChanged change_id=2 node=1,2 new_parent=1,1 old_parent=null",
         changes[0]);
     EXPECT_EQ("[node=1,2 parent=1,1 view=null]",
               ChangeNodeDescription(connection2_->changes()));
   }
 
   // Delete 2.
   {
-    ASSERT_TRUE(connection_->DeleteNode(BuildNodeId(1, 2), 2));
+    ASSERT_TRUE(connection_->DeleteNode(BuildNodeId(1, 2), 3));
 
     connection2_->DoRunLoopUntilChangesCount(1);
     const Changes changes(ChangesToDescription1(connection2_->changes()));
     ASSERT_EQ(1u, changes.size());
-    EXPECT_EQ("NodeDeleted change_id=2 node=1,2", changes[0]);
+    EXPECT_EQ("NodeDeleted change_id=3 node=1,2", changes[0]);
   }
 
   // Create 2 again, and add it back to 1. Should get the same notification.
   ASSERT_TRUE(connection_->CreateNode(BuildNodeId(1, 2)));
   {
-    ASSERT_TRUE(connection_->AddNode(BuildNodeId(1, 1), BuildNodeId(1, 2), 3));
+    ASSERT_TRUE(connection_->AddNode(BuildNodeId(1, 1), BuildNodeId(1, 2), 4));
 
     connection2_->DoRunLoopUntilChangesCount(1);
     const Changes changes(ChangesToDescription1(connection2_->changes()));
     EXPECT_EQ(
-        "HierarchyChanged change_id=3 node=1,2 new_parent=1,1 old_parent=null",
+        "HierarchyChanged change_id=4 node=1,2 new_parent=1,1 old_parent=null",
         changes[0]);
     EXPECT_EQ("[node=1,2 parent=1,1 view=null]",
               ChangeNodeDescription(connection2_->changes()));
   }
 }
 
 // Assertions around setting a view.
 TEST_F(ViewManagerTest, SetView) {
   // Create nodes 1, 2 and 3 and the view 11. Nodes 2 and 3 are parented to 1.
   ASSERT_TRUE(connection_->CreateNode(BuildNodeId(1, 1)));
@@ skipping 39 matching lines @@
   ASSERT_TRUE(connection_->CreateView(BuildViewId(1, 11)));
 
   // Set view 11 on node 2.
   ASSERT_TRUE(connection_->SetView(BuildNodeId(1, 2), BuildViewId(1, 11)));
 
   ASSERT_NO_FATAL_FAILURE(EstablishSecondConnection(false));
 
   // Delete node 2. The second connection should not see this because the node
   // was not known to it.
   {
-    ASSERT_TRUE(connection_->DeleteNode(BuildNodeId(1, 2), 1));
+    ASSERT_TRUE(connection_->DeleteNode(BuildNodeId(1, 2), 2));
 
     connection2_->DoRunLoopUntilChangesCount(1);
     const Changes changes(ChangesToDescription1(connection2_->changes()));
     ASSERT_EQ(1u, changes.size());
-    EXPECT_EQ("ServerChangeIdAdvanced 2", changes[0]);
+    EXPECT_EQ("ServerChangeIdAdvanced 3", changes[0]);
   }
 
   // Parent 3 to 1.
-  ASSERT_TRUE(connection_->AddNode(BuildNodeId(1, 1), BuildNodeId(1, 3), 2));
+  ASSERT_TRUE(connection_->AddNode(BuildNodeId(1, 1), BuildNodeId(1, 3), 3));
   connection2_->DoRunLoopUntilChangesCount(1);
 
   // Set view 11 on node 3.
   {
     ASSERT_TRUE(connection_->SetView(BuildNodeId(1, 3), BuildViewId(1, 11)));
 
     connection2_->DoRunLoopUntilChangesCount(1);
     const Changes changes(ChangesToDescription1(connection2_->changes()));
     ASSERT_EQ(1u, changes.size());
     EXPECT_EQ("ViewReplaced node=1,3 new_view=1,11 old_view=null", changes[0]);
   }
 
   // Delete 3.
   {
-    ASSERT_TRUE(connection_->DeleteNode(BuildNodeId(1, 3), 3));
+    ASSERT_TRUE(connection_->DeleteNode(BuildNodeId(1, 3), 4));
 
     connection2_->DoRunLoopUntilChangesCount(1);
     const Changes changes(ChangesToDescription1(connection2_->changes()));
     ASSERT_EQ(1u, changes.size());
-    EXPECT_EQ("NodeDeleted change_id=3 node=1,3", changes[0]);
+    EXPECT_EQ("NodeDeleted change_id=4 node=1,3", changes[0]);
   }
 }
 
 // Sets view from one connection on another.
 TEST_F(ViewManagerTest, SetViewFromSecondConnection) {
   ASSERT_NO_FATAL_FAILURE(EstablishSecondConnection(true));
 
   ASSERT_TRUE(connection_->CreateNode(BuildNodeId(1, 2)));
 
   // Create a view in the second connection.
@@ skipping 18 matching lines @@
     EXPECT_EQ("ViewDeleted view=2,51", changes[1]);
   }
 }
 
 // Assertions for GetNodeTree.
 TEST_F(ViewManagerTest, GetNodeTree) {
   ASSERT_NO_FATAL_FAILURE(EstablishSecondConnection(true));
 
   // Create 11 in first connection and make it a child of 1.
   ASSERT_TRUE(connection_->CreateNode(BuildNodeId(1, 11)));
-  ASSERT_TRUE(connection_->AddNode(BuildNodeId(0, 1), BuildNodeId(1, 1), 1));
-  ASSERT_TRUE(connection_->AddNode(BuildNodeId(1, 1), BuildNodeId(1, 11), 2));
+  ASSERT_TRUE(connection_->AddNode(BuildNodeId(0, 1), BuildNodeId(1, 1), 2));
+  ASSERT_TRUE(connection_->AddNode(BuildNodeId(1, 1), BuildNodeId(1, 11), 3));
 
   // Create two nodes in second connection, 2 and 3, both children of 1.
   ASSERT_TRUE(connection2_->CreateNode(BuildNodeId(2, 2)));
   ASSERT_TRUE(connection2_->CreateNode(BuildNodeId(2, 3)));
-  ASSERT_TRUE(connection2_->AddNode(BuildNodeId(1, 1), BuildNodeId(2, 2), 3));
-  ASSERT_TRUE(connection2_->AddNode(BuildNodeId(1, 1), BuildNodeId(2, 3), 4));
+  ASSERT_TRUE(connection2_->AddNode(BuildNodeId(1, 1), BuildNodeId(2, 2), 4));
+  ASSERT_TRUE(connection2_->AddNode(BuildNodeId(1, 1), BuildNodeId(2, 3), 5));
 
   // Attach view to node 11 in the first connection.
   ASSERT_TRUE(connection_->CreateView(BuildViewId(1, 51)));
   ASSERT_TRUE(connection_->SetView(BuildNodeId(1, 11), BuildViewId(1, 51)));
 
   // Verifies GetNodeTree() on the root.
   {
     std::vector<TestNode> nodes;
     connection_->GetNodeTree(BuildNodeId(0, 1), &nodes);
     ASSERT_EQ(5u, nodes.size());
@@ skipping 51 matching lines @@
   ASSERT_TRUE(connection_->CreateNode(BuildNodeId(1, 2)));
   ASSERT_TRUE(connection_->CreateNode(BuildNodeId(1, 3)));
 
   // Parent 1 to the root.
   ASSERT_TRUE(connection_->AddNode(BuildNodeId(0, 1), BuildNodeId(1, 1), 1));
 
   // Establish the second connection with roots 1 and 3.
   {
     ASSERT_NO_FATAL_FAILURE(EstablishSecondConnection(false));
 
-    ASSERT_TRUE(connection_->Embed(BuildNodeId(1, 3)));
+    ASSERT_TRUE(connection_->Embed(BuildNodeId(1, 3), kTestServiceURL));
     connection2_->DoRunLoopUntilChangesCount(1);
     const Changes changes(ChangesToDescription1(connection2_->changes()));
     ASSERT_EQ(1u, changes.size());
     EXPECT_EQ("OnRootAdded", changes[0]);
     EXPECT_EQ("[node=1,3 parent=null view=null]",
               ChangeNodeDescription(connection2_->changes()));
   }
 
   // Create 4 and add it to the root, connection 2 should only get id advanced.
   {
     ASSERT_TRUE(connection_->CreateNode(BuildNodeId(1, 4)));
-    ASSERT_TRUE(connection_->AddNode(BuildNodeId(0, 1), BuildNodeId(1, 4), 2));
+    ASSERT_TRUE(connection_->AddNode(BuildNodeId(0, 1), BuildNodeId(1, 4), 4));
 
     connection2_->DoRunLoopUntilChangesCount(1);
     const Changes changes(ChangesToDescription1(connection2_->changes()));
     ASSERT_EQ(1u, changes.size());
-    EXPECT_EQ("ServerChangeIdAdvanced 3", changes[0]);
+    EXPECT_EQ("ServerChangeIdAdvanced 5", changes[0]);
   }
 
   // Move 4 under 3, this should expose 4 to the client.
   {
-    ASSERT_TRUE(connection_->AddNode(BuildNodeId(1, 3), BuildNodeId(1, 4), 3));
+    ASSERT_TRUE(connection_->AddNode(BuildNodeId(1, 3), BuildNodeId(1, 4), 5));
     connection2_->DoRunLoopUntilChangesCount(1);
     const Changes changes(ChangesToDescription1(connection2_->changes()));
     ASSERT_EQ(1u, changes.size());
     EXPECT_EQ(
-        "HierarchyChanged change_id=3 node=1,4 new_parent=1,3 "
+        "HierarchyChanged change_id=5 node=1,4 new_parent=1,3 "
         "old_parent=null", changes[0]);
     EXPECT_EQ("[node=1,4 parent=1,3 view=null]",
               ChangeNodeDescription(connection2_->changes()));
   }
 
   // Move 4 under 2, since 2 isn't a root client should get a delete.
   {
-    ASSERT_TRUE(connection_->AddNode(BuildNodeId(1, 2), BuildNodeId(1, 4), 4));
+    ASSERT_TRUE(connection_->AddNode(BuildNodeId(1, 2), BuildNodeId(1, 4), 6));
     connection2_->DoRunLoopUntilChangesCount(1);
     const Changes changes(ChangesToDescription1(connection2_->changes()));
     ASSERT_EQ(1u, changes.size());
-    EXPECT_EQ("NodeDeleted change_id=4 node=1,4", changes[0]);
+    EXPECT_EQ("NodeDeleted change_id=6 node=1,4", changes[0]);
   }
 
   // Delete 4, client shouldn't receive a delete since it should no longer know
   // about 4.
   {
-    ASSERT_TRUE(connection_->DeleteNode(BuildNodeId(1, 4), 5));
+    ASSERT_TRUE(connection_->DeleteNode(BuildNodeId(1, 4), 7));
 
     connection2_->DoRunLoopUntilChangesCount(1);
     const Changes changes(ChangesToDescription1(connection2_->changes()));
     ASSERT_EQ(1u, changes.size());
-    EXPECT_EQ("ServerChangeIdAdvanced 6", changes[0]);
+    EXPECT_EQ("ServerChangeIdAdvanced 8", changes[0]);
   }
 }
 
 // Verify AddNode fails when trying to manipulate nodes in other roots.
 TEST_F(ViewManagerTest, CantMoveNodesFromOtherRoot) {
   // Create 1 and 2 in the first connection.
   ASSERT_TRUE(connection_->CreateNode(BuildNodeId(1, 1)));
   ASSERT_TRUE(connection_->CreateNode(BuildNodeId(1, 2)));
 
   ASSERT_NO_FATAL_FAILURE(EstablishSecondConnection(false));
@@ skipping 14 matching lines @@
   ASSERT_TRUE(connection_->CreateNode(BuildNodeId(1, 1)));
   ASSERT_TRUE(connection_->CreateNode(BuildNodeId(1, 2)));
 
   ASSERT_TRUE(connection_->AddNode(BuildNodeId(0, 1), BuildNodeId(1, 1), 1));
   ASSERT_TRUE(connection_->AddNode(BuildNodeId(0, 1), BuildNodeId(1, 2), 2));
 
   // Establish the second connection and give it the root 1.
   ASSERT_NO_FATAL_FAILURE(EstablishSecondConnection(false));
 
   // Connection 2 should not be able to remove node 2 or 1 from its parent.
-  ASSERT_FALSE(connection2_->RemoveNodeFromParent(BuildNodeId(1, 2), 3));
-  ASSERT_FALSE(connection2_->RemoveNodeFromParent(BuildNodeId(1, 1), 3));
+  ASSERT_FALSE(connection2_->RemoveNodeFromParent(BuildNodeId(1, 2), 4));
+  ASSERT_FALSE(connection2_->RemoveNodeFromParent(BuildNodeId(1, 1), 4));
 
   // Create nodes 10 and 11 in 2.
   ASSERT_TRUE(connection2_->CreateNode(BuildNodeId(2, 10)));
   ASSERT_TRUE(connection2_->CreateNode(BuildNodeId(2, 11)));
 
   // Parent 11 to 10.
-  ASSERT_TRUE(connection2_->AddNode(BuildNodeId(2, 10), BuildNodeId(2, 11), 3));
+  ASSERT_TRUE(connection2_->AddNode(BuildNodeId(2, 10), BuildNodeId(2, 11), 4));
   // Remove 11 from 10.
-  ASSERT_TRUE(connection2_->RemoveNodeFromParent( BuildNodeId(2, 11), 4));
+  ASSERT_TRUE(connection2_->RemoveNodeFromParent( BuildNodeId(2, 11), 5));
 
   // Verify nothing was actually removed.
   {
     std::vector<TestNode> nodes;
     connection_->GetNodeTree(BuildNodeId(0, 1), &nodes);
     ASSERT_EQ(3u, nodes.size());
     EXPECT_EQ("node=0,1 parent=null view=null", nodes[0].ToString());
     EXPECT_EQ("node=1,1 parent=0,1 view=null", nodes[1].ToString());
     EXPECT_EQ("node=1,2 parent=0,1 view=null", nodes[2].ToString());
   }
@@ skipping 50 matching lines @@
   ASSERT_TRUE(connection_->CreateNode(BuildNodeId(1, 1)));
   ASSERT_TRUE(connection_->CreateNode(BuildNodeId(1, 2)));
 
   ASSERT_TRUE(connection_->AddNode(BuildNodeId(1, 1), BuildNodeId(1, 2), 1));
 
   ASSERT_NO_FATAL_FAILURE(EstablishSecondConnection(false));
 
   // Try to connect again to 1,1, this should fail as already connected to that
   // root.
   {
-    ASSERT_FALSE(connection_->Embed(BuildNodeId(1, 1)));
+    ASSERT_FALSE(connection_->Embed(BuildNodeId(1, 1), kTestServiceURL));
   }
 
   // Connecting to 1,2 should succeed and end up in connection2.
   {
-    ASSERT_TRUE(connection_->Embed(BuildNodeId(1, 2)));
+    ASSERT_TRUE(connection_->Embed(BuildNodeId(1, 2), kTestServiceURL));
     connection2_->DoRunLoopUntilChangesCount(1);
     const Changes changes(ChangesToDescription1(connection2_->changes()));
     ASSERT_EQ(1u, changes.size());
     EXPECT_EQ("OnRootAdded", changes[0]);
     EXPECT_EQ("[node=1,2 parent=1,1 view=null]",
               ChangeNodeDescription(connection2_->changes()));
   }
 }
 
 TEST_F(ViewManagerTest, OnViewInput) {
@@ skipping 10 matching lines @@
     connection_->view_manager()->DispatchOnViewInputEvent(
         BuildViewId(2, 11),
         event.Pass());
     connection2_->DoRunLoopUntilChangesCount(1);
     const Changes changes(ChangesToDescription1(connection2_->changes()));
     ASSERT_EQ(1u, changes.size());
     EXPECT_EQ("InputEvent view=2,11 event_action=1", changes[0]);
   }
 }
 
+TEST_F(ViewManagerTest, EmbedWithSameNodeId) {
+  ASSERT_NO_FATAL_FAILURE(EstablishSecondConnection(true));
+
+  // Create a third connection.
+  ViewManagerProxy* connection3 = NULL;
+  {
+    ASSERT_TRUE(connection_->Embed(BuildNodeId(1, 1), kTestServiceURL2));
+    connection3 = ViewManagerProxy::WaitForInstance();
+    ASSERT_TRUE(connection3 != NULL);
+    connection3->DoRunLoopUntilChangesCount(1);
+    const Changes changes(ChangesToDescription1(connection3->changes()));
+    ASSERT_EQ(1u, changes.size());
+    EXPECT_EQ("OnConnectionEstablished creator=mojo:test_url", changes[0]);
+  }
+
+  // Connection2 should have been told the node was deleted.
+  {
+    connection2_->DoRunLoopUntilChangesCount(1);
+    const Changes changes(ChangesToDescription1(connection2_->changes()));
+    ASSERT_EQ(1u, changes.size());
+    EXPECT_EQ("NodeDeleted change_id=2 node=1,1", changes[0]);
+  }
+
+  // Connection2 has no root. Verify it can't see node 1,1 anymore.
+  {
+    std::vector<TestNode> nodes;
+    connection2_->GetNodeTree(BuildNodeId(1, 1), &nodes);
+    EXPECT_TRUE(nodes.empty());
+  }
+
+  connection3->Destroy();
+}
+
+TEST_F(ViewManagerTest, EmbedWithSameNodeId2) {
+  ASSERT_NO_FATAL_FAILURE(EstablishSecondConnection(true));
+
+  // Create a third connection.
+  ViewManagerProxy* connection3 = NULL;
+  {
+    ASSERT_TRUE(connection_->Embed(BuildNodeId(1, 1), kTestServiceURL2));
+    connection3 = ViewManagerProxy::WaitForInstance();
+    ASSERT_TRUE(connection3 != NULL);
+    connection3->DoRunLoopUntilChangesCount(1);
+    const Changes changes(ChangesToDescription1(connection3->changes()));
+    ASSERT_EQ(1u, changes.size());
+    EXPECT_EQ("OnConnectionEstablished creator=mojo:test_url", changes[0]);
+  }
+
+  // Connection2 should have been told the node was deleted.
+  connection2_->DoRunLoopUntilChangesCount(1);
+  connection2_->ClearChanges();
+
+  // Create a node in the third connection and parent it to the root.
+  ASSERT_TRUE(connection3->CreateNode(BuildNodeId(3, 1)));
+  ASSERT_TRUE(connection3->AddNode(BuildNodeId(1, 1), BuildNodeId(3, 1), 3));
+
+  // Connection 1 should have been told about the add (it owns the node).
+  {
+    connection_->DoRunLoopUntilChangesCount(1);
+    const Changes changes(ChangesToDescription1(connection_->changes()));
+    ASSERT_EQ(1u, changes.size());
+    EXPECT_EQ(
+        "HierarchyChanged change_id=3 node=3,1 new_parent=1,1 old_parent=null",
+        changes[0]);
+  }
+
+  // connection2_ should get an advance.
+  connection2_->DoRunLoopUntilChangesCount(1);
+  connection2_->ClearChanges();
+
+  // Embed 1,1 back in connection 2.
+  {
+    // 2 should be told about the new embed.
+    ASSERT_TRUE(connection_->Embed(BuildNodeId(1, 1), kTestServiceURL));
+    connection2_->DoRunLoopUntilChangesCount(1);
+    const std::vector<Change>& changes(connection2_->changes());
+    ASSERT_EQ(1u, changes.size());
+    EXPECT_EQ("OnRootAdded", ChangesToDescription1(changes)[0]);
+    EXPECT_EQ("[node=1,1 parent=null view=null]",
+              ChangeNodeDescription(changes));
+
+    // And 3 should get a delete.
+    connection3->DoRunLoopUntilChangesCount(1);
+    ASSERT_EQ(1u, connection3->changes().size());
+    EXPECT_EQ("NodeDeleted change_id=4 node=1,1",
+              ChangesToDescription1(connection3->changes())[0]);
+  }
+
+  // Connection3 has no root. Verify it can't see node 1,1 anymore.
+  {
+    std::vector<TestNode> nodes;
+    connection3->GetNodeTree(BuildNodeId(1, 1), &nodes);
+    EXPECT_TRUE(nodes.empty());
+  }
+
+  // Verify 3,1 is no longer parented to 1,1. We have to do this from 1,1 as
+  // connection3 can no longer see 1,1.
+  {
+    std::vector<TestNode> nodes;
+    connection_->GetNodeTree(BuildNodeId(1, 1), &nodes);
+    ASSERT_EQ(1u, nodes.size());
+    EXPECT_EQ("node=1,1 parent=null view=null", nodes[0].ToString());
+  }
+
+  // Verify connection3 can still see the node it created 3,1.
+  {
+    std::vector<TestNode> nodes;
+    connection3->GetNodeTree(BuildNodeId(3, 1), &nodes);
+    ASSERT_EQ(1u, nodes.size());
+    EXPECT_EQ("node=3,1 parent=null view=null", nodes[0].ToString());
+  }
+
+  connection3->Destroy();
+}
+
 // TODO(sky): add coverage of test that destroys connections and ensures other
 // connections get deletion notification (or advanced server id).
 
 // TODO(sky): need to better track changes to initial connection. For example,
 // that SetBounsdNodes/AddNode and the like don't result in messages to the
 // originating connection.
 
 // TODO(beng): Add tests for focus:
 // - focus between two nodes known to a connection
 // - focus between nodes unknown to one of the connections.
 // - focus between nodes unknown to either connection.
 
 }  // namespace service
 }  // namespace view_manager
 }  // namespace mojo