Get most of the View Manager client lib tests to pass again.

mojo/services/public/cpp/view_manager/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 "base/auto_reset.h"
 #include "base/bind.h"
 #include "base/logging.h"
 #include "mojo/public/cpp/application/application.h"
 #include "mojo/service_manager/service_manager.h"
 #include "mojo/services/public/cpp/view_manager/lib/view_manager_private.h"
 #include "mojo/services/public/cpp/view_manager/lib/view_manager_synchronizer.h"
 #include "mojo/services/public/cpp/view_manager/lib/view_tree_node_private.h"
 #include "mojo/services/public/cpp/view_manager/util.h"
 #include "mojo/services/public/cpp/view_manager/view.h"
 #include "mojo/services/public/cpp/view_manager/view_observer.h"
 #include "mojo/services/public/cpp/view_manager/view_tree_node_observer.h"
 #include "mojo/shell/shell_test_helper.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace mojo {
 namespace view_manager {
 namespace {
 
 const char kTestServiceURL[] = "mojo:test_url";
+const char kTestServiceURL2[] = "mojo:test_url2";
 
 base::RunLoop* current_run_loop = NULL;
 
 void DoRunLoop() {
   base::RunLoop run_loop;
   current_run_loop = &run_loop;
   current_run_loop->Run();
   current_run_loop = NULL;
 }
 
@@ skipping 107 matching lines @@
         tree_size_(tree_size) {}
   virtual ~TreeSizeMatchesObserver() {}
 
   bool IsTreeCorrectSize() {
     return CountNodes(tree_) == tree_size_;
   }
 
  private:
   // Overridden from ViewTreeNodeObserver:
   virtual void OnTreeChange(const TreeChangeParams& params) OVERRIDE {
-    if (params.phase != ViewTreeNodeObserver::DISPOSITION_CHANGED)
-      return;
     if (IsTreeCorrectSize())
       QuitRunLoop();
   }
 
   size_t CountNodes(const ViewTreeNode* node) const {
     size_t count = 1;
     ViewTreeNode::Children::const_iterator it = node->children().begin();
     for (; it != node->children().end(); ++it)
       count += CountNodes(*it);
     return count;
   }
 
   ViewTreeNode* tree_;
   size_t tree_size_;
+
   DISALLOW_COPY_AND_ASSIGN(TreeSizeMatchesObserver);
 };
 
 void WaitForTreeSizeToMatch(ViewTreeNode* node, size_t tree_size) {
   TreeSizeMatchesObserver observer(node, tree_size);
   if (observer.IsTreeCorrectSize())
     return;
   node->AddObserver(&observer);
   DoRunLoop();
   node->RemoveObserver(&observer);
@@ skipping 100 matching lines @@
 
 }  // namespace
 
 // ViewManager -----------------------------------------------------------------
 
 // These tests model synchronization of two peer connections to the view manager
 // service, that are given access to some root node.
 
 class ViewManagerTest : public testing::Test {
  public:
-  ViewManagerTest() : commit_count_(0) {}
+  ViewManagerTest()
+      : connect_loop_(NULL),
+        loaded_view_manager_(NULL),
+        window_manager_(NULL),
+        commit_count_(0) {}
 
  protected:
-  ViewManager* view_manager_1() { return view_manager_1_; }
-  ViewManager* view_manager_2() { return view_manager_2_; }
+  ViewManager* window_manager() { return window_manager_; }
 
   ViewTreeNode* CreateNodeInParent(ViewTreeNode* parent) {
     ViewManager* parent_manager = ViewTreeNodePrivate(parent).view_manager();
     ViewTreeNode* node = ViewTreeNode::Create(parent_manager);
     parent->AddChild(node);
     return node;
   }
 
-  void DestroyViewManager1() {
-    // view_manager_1_.reset();
+  // Embeds another version of the test app @ node.
+  ViewManager* Embed(ViewManager* view_manager, ViewTreeNode* node) {
+    DCHECK_EQ(view_manager, ViewTreeNodePrivate(node).view_manager());
+    view_manager->Embed(kTestServiceURL2, node);
+    RunRunLoop();
+    return GetLoadedViewManager();
+  }
+
+  // TODO(beng): remove these methods once all the tests are migrated.
+  void DestroyViewManager1() {}
+  ViewManager* view_manager_1() { return NULL; }
+  ViewManager* view_manager_2() { return NULL; }
+
+  ViewManager* GetLoadedViewManager() {
+    ViewManager* view_manager = loaded_view_manager_;
+    loaded_view_manager_ = NULL;
+    return view_manager;
   }
 
  private:
   // Overridden from testing::Test:
   virtual void SetUp() OVERRIDE {
     test_helper_.Init();
-    ConnectServiceLoader* loader =
-        new ConnectServiceLoader(
+    test_helper_.SetLoaderForURL(
+        scoped_ptr<ServiceLoader>(new ConnectServiceLoader(
             base::Bind(&ViewManagerTest::OnViewManagerLoaded,
-                       base::Unretained(this)));
+                       base::Unretained(this)))),
+        GURL(kTestServiceURL));
     test_helper_.SetLoaderForURL(
-        scoped_ptr<ServiceLoader>(loader),
-        GURL(kTestServiceURL));
+        scoped_ptr<ServiceLoader>(new ConnectServiceLoader(
+            base::Bind(&ViewManagerTest::OnViewManagerLoaded,
+                       base::Unretained(this)))),
+        GURL(kTestServiceURL2));
 
     ConnectToService(test_helper_.service_provider(),
                      "mojo:mojo_view_manager",
                      &view_manager_init_);
     ASSERT_TRUE(ViewManagerInitConnect(view_manager_init_.get(),
                                        kTestServiceURL));
   }
 
   void ViewManagerInitConnectCallback(bool* result_cache,
                                       bool result) {
     *result_cache = result;
   }
 
   bool ViewManagerInitConnect(IViewManagerInit* view_manager_init,
                               const std::string& url) {
     bool result = false;
     view_manager_init->Connect(
         url,
         base::Bind(&ViewManagerTest::ViewManagerInitConnectCallback,
                    base::Unretained(this), &result));
-    init_loop_.Run();
+    RunRunLoop();
+    window_manager_ = GetLoadedViewManager();
     return result;
   }
 
   void OnViewManagerLoaded(ViewManager* view_manager) {
-    init_loop_.Quit();
+    loaded_view_manager_ = view_manager;
+    connect_loop_->Quit();
+  }
+
+  void RunRunLoop() {
+    base::RunLoop run_loop;
+    connect_loop_ = &run_loop;
+    connect_loop_->Run();
+    connect_loop_ = NULL;
   }
 
   base::MessageLoop loop_;
-  base::RunLoop init_loop_;
+  base::RunLoop* connect_loop_;
   shell::ShellTestHelper test_helper_;
   IViewManagerInitPtr view_manager_init_;
-  ViewManager* view_manager_1_;
-  ViewManager* view_manager_2_;
+  // Used to receive the most recent view manager loaded by an embed action.
+  ViewManager* loaded_view_manager_;
+  // The View Manager connection held by the window manager (app running at the
+  // root node).
+  ViewManager* window_manager_;
   int commit_count_;
 
   DISALLOW_COPY_AND_ASSIGN(ViewManagerTest);
 };
 
-// Base class for helpers that quit the current runloop after a specific tree
-// change is observed by a view manager.
-class TreeObserverBase : public ViewTreeNodeObserver {
- public:
-  explicit TreeObserverBase(ViewManager* view_manager)
-      : view_manager_(view_manager) {
-    view_manager_->tree()->AddObserver(this);
-  }
-  virtual ~TreeObserverBase() {
-    view_manager_->tree()->RemoveObserver(this);
-  }
+TEST_F(ViewManagerTest, SetUp) {}
 
- protected:
-  virtual bool ShouldQuitRunLoop(const TreeChangeParams& params) = 0;
-
-  ViewManager* view_manager() { return view_manager_; }
-
- private:
-  // Overridden from ViewTreeNodeObserver:
-  virtual void OnTreeChange(const TreeChangeParams& params) OVERRIDE {
-    if (ShouldQuitRunLoop(params))
-      QuitRunLoop();
-  }
-
-  ViewManager* view_manager_;
-  DISALLOW_COPY_AND_ASSIGN(TreeObserverBase);
-};
-
-class HierarchyChanged_NodeCreatedObserver : public TreeObserverBase {
- public:
-  explicit HierarchyChanged_NodeCreatedObserver(ViewManager* view_manager)
-      : TreeObserverBase(view_manager) {}
-  virtual ~HierarchyChanged_NodeCreatedObserver() {}
-
- private:
-  // Overridden from TreeObserverBase:
-  virtual bool ShouldQuitRunLoop(const TreeChangeParams& params) OVERRIDE {
-    if (params.phase != ViewTreeNodeObserver::DISPOSITION_CHANGED)
-      return false;
-    return params.receiver == view_manager()->tree() &&
-        !params.old_parent &&
-        params.new_parent == view_manager()->tree();
-  }
-
-  DISALLOW_COPY_AND_ASSIGN(HierarchyChanged_NodeCreatedObserver);
-};
-
-// TODO(beng): reenable these once converted to new way of connecting.
-
-TEST_F(ViewManagerTest, SetUp) {
+TEST_F(ViewManagerTest, Embed) {
+  ViewTreeNode* node = ViewTreeNode::Create(window_manager());
+  window_manager()->tree()->AddChild(node);
+  ViewManager* embedded = Embed(window_manager(), node);
+  EXPECT_TRUE(NULL != embedded);
 }
 
-TEST_F(ViewManagerTest, DISABLED_HierarchyChanged_NodeCreated) {
-  HierarchyChanged_NodeCreatedObserver observer(view_manager_2());
-  ViewTreeNode* node1 = ViewTreeNode::Create(view_manager_1());
-  view_manager_1()->tree()->AddChild(node1);
-  DoRunLoop();
-
-  EXPECT_EQ(view_manager_2()->tree()->children().front()->id(), node1->id());
+// When Window Manager embeds A @ N, then creates N2 and parents to N, N becomes
+// visible to A.
+// TODO(beng): verify whether or not this is a policy we like.
+TEST_F(ViewManagerTest, HierarchyChanged_NodeAdded) {
+  ViewTreeNode* node = ViewTreeNode::Create(window_manager());
+  window_manager()->tree()->AddChild(node);
+  ViewManager* embedded = Embed(window_manager(), node);
+  ViewTreeNode* nested = ViewTreeNode::Create(window_manager());
+  node->AddChild(nested);
+  WaitForTreeSizeToMatch(embedded->tree(), 2);
+  EXPECT_EQ(embedded->tree()->children().front()->id(), nested->id());
 }
 
-// Quits the current runloop when the root is notified about a node moved from
-// |old_parent_id| to |new_parent_id|.
-class HierarchyChanged_NodeMovedObserver : public TreeObserverBase {
- public:
-  HierarchyChanged_NodeMovedObserver(ViewManager* view_manager,
-                                     TransportNodeId old_parent_id,
-                                     TransportNodeId new_parent_id)
-      : TreeObserverBase(view_manager),
-        old_parent_id_(old_parent_id),
-        new_parent_id_(new_parent_id) {}
-  virtual ~HierarchyChanged_NodeMovedObserver() {}
+// Window manager has two nodes, N1 & N2. Embeds A at N1. Creates node N21,
+// a child of N2. Reparents N2 to N1. N1 should become visible to A.
+// TODO(beng): verify whether or not this is a policy we like.
+TEST_F(ViewManagerTest, HierarchyChanged_NodeMoved) {
+  ViewTreeNode* node1 = ViewTreeNode::Create(window_manager());
+  window_manager()->tree()->AddChild(node1);
+  ViewManager* embedded = Embed(window_manager(), node1);
+  WaitForTreeSizeToMatch(embedded->tree(), 1);
 
- private:
-  // Overridden from TreeObserverBase:
-  virtual bool ShouldQuitRunLoop(const TreeChangeParams& params) OVERRIDE {
-    if (params.phase != ViewTreeNodeObserver::DISPOSITION_CHANGED)
-      return false;
-    return params.receiver == view_manager()->tree() &&
-        params.old_parent->id() == old_parent_id_&&
-        params.new_parent->id() == new_parent_id_;
-  }
+  ViewTreeNode* node2 = ViewTreeNode::Create(window_manager());
+  window_manager()->tree()->AddChild(node2);
+  WaitForTreeSizeToMatch(embedded->tree(), 1);
+  EXPECT_TRUE(embedded->tree()->children().empty());
 
-  TransportNodeId old_parent_id_;
-  TransportNodeId new_parent_id_;
+  ViewTreeNode* node21 = ViewTreeNode::Create(window_manager());
+  node2->AddChild(node21);
+  WaitForTreeSizeToMatch(embedded->tree(), 1);
+  EXPECT_TRUE(embedded->tree()->children().empty());
 
-  DISALLOW_COPY_AND_ASSIGN(HierarchyChanged_NodeMovedObserver);
-};
-
-TEST_F(ViewManagerTest, DISABLED_HierarchyChanged_NodeMoved) {
-  ViewTreeNode* node1 = CreateNodeInParent(view_manager_1()->tree());
-  ViewTreeNode* node2 = CreateNodeInParent(view_manager_1()->tree());
-  ViewTreeNode* node21 = CreateNodeInParent(node2);
-  WaitForTreeSizeToMatch(view_manager_2()->tree(), 4);
-
-  HierarchyChanged_NodeMovedObserver observer(view_manager_2(),
-                                              node2->id(),
-                                              node1->id());
-
+  // Makes node21 visible to |embedded|.
   node1->AddChild(node21);
-  DoRunLoop();
-
-  ViewTreeNode* tree2 = view_manager_2()->tree();
-
-  EXPECT_EQ(tree2->children().size(), 2u);
-  ViewTreeNode* tree2_node1 = tree2->GetChildById(node1->id());
-  EXPECT_EQ(tree2_node1->children().size(), 1u);
-  ViewTreeNode* tree2_node2 = tree2->GetChildById(node2->id());
-  EXPECT_TRUE(tree2_node2->children().empty());
-  ViewTreeNode* tree2_node21 = tree2->GetChildById(node21->id());
-  EXPECT_EQ(tree2_node21->parent(), tree2_node1);
+  WaitForTreeSizeToMatch(embedded->tree(), 2);
+  EXPECT_FALSE(embedded->tree()->children().empty());
+  EXPECT_EQ(embedded->tree()->children().front()->id(), node21->id());
 }
 
-class HierarchyChanged_NodeRemovedObserver : public TreeObserverBase {
- public:
-  HierarchyChanged_NodeRemovedObserver(ViewManager* view_manager)
-      : TreeObserverBase(view_manager) {}
-  virtual ~HierarchyChanged_NodeRemovedObserver() {}
+// Window manager has two nodes, N1 and N11. Embeds A at N1. Removes N11 from
+// N1. N11 should disappear from A.
+// TODO(beng): verify whether or not this is a policy we like.
+TEST_F(ViewManagerTest, HierarchyChanged_NodeRemoved) {
+  ViewTreeNode* node = ViewTreeNode::Create(window_manager());
+  window_manager()->tree()->AddChild(node);
+  ViewTreeNode* nested = ViewTreeNode::Create(window_manager());
+  node->AddChild(nested);
 
- private:
-  // Overridden from TreeObserverBase:
-  virtual bool ShouldQuitRunLoop(const TreeChangeParams& params) OVERRIDE {
-    if (params.phase != ViewTreeNodeObserver::DISPOSITION_CHANGING)
-      return false;
-    return params.receiver == view_manager()->tree() &&
-        params.old_parent->id() == params.receiver->id() &&
-        params.new_parent == 0;
-  }
+  ViewManager* embedded = Embed(window_manager(), node);
+  EXPECT_EQ(embedded->tree()->children().front()->id(), nested->id());
 
-  DISALLOW_COPY_AND_ASSIGN(HierarchyChanged_NodeRemovedObserver);
-};
-
-TEST_F(ViewManagerTest, DISABLED_HierarchyChanged_NodeRemoved) {
-  ViewTreeNode* node1 = CreateNodeInParent(view_manager_1()->tree());
-  WaitForTreeSizeToMatch(view_manager_2()->tree(), 2);
-
-  HierarchyChanged_NodeRemovedObserver observer(view_manager_2());
-
-  view_manager_1()->tree()->RemoveChild(node1);
-  DoRunLoop();
-
-  ViewTreeNode* tree2 = view_manager_2()->tree();
-
-  EXPECT_TRUE(tree2->children().empty());
+  node->RemoveChild(nested);
+  WaitForTreeSizeToMatch(embedded->tree(), 1);
+  EXPECT_TRUE(embedded->tree()->children().empty());
 }
 
-TEST_F(ViewManagerTest, DISABLED_NodeDestroyed) {
-  ViewTreeNode* node1 = CreateNodeInParent(view_manager_1()->tree());
-  WaitForTreeSizeToMatch(view_manager_2()->tree(), 2);
+// Window manager has two nodes, N1 and N11. Embeds A at N1. Destroys N11.
+// N11 should disappear from A.
+// TODO(beng): verify whether or not this is a policy we like.
+TEST_F(ViewManagerTest, NodeDestroyed) {
+  ViewTreeNode* node = ViewTreeNode::Create(window_manager());
+  window_manager()->tree()->AddChild(node);
+  ViewTreeNode* nested = ViewTreeNode::Create(window_manager());
+  node->AddChild(nested);
 
-  // |node1| will be deleted after calling Destroy() below.
-  TransportNodeId id = node1->id();
-  node1->Destroy();
+  ViewManager* embedded = Embed(window_manager(), node);
+  EXPECT_EQ(embedded->tree()->children().front()->id(), nested->id());
+
+  // |nested| will be deleted after calling Destroy() below.
+  TransportNodeId id = nested->id();
+  nested->Destroy();
 
   std::set<TransportNodeId> nodes;
   nodes.insert(id);
-  WaitForDestruction(view_manager_2(), &nodes, NULL);
+  WaitForDestruction(embedded, &nodes, NULL);
 
-  EXPECT_TRUE(view_manager_2()->tree()->children().empty());
-  EXPECT_EQ(NULL, view_manager_2()->GetNodeById(id));
+  EXPECT_TRUE(embedded->tree()->children().empty());
+  EXPECT_EQ(NULL, embedded->GetNodeById(id));
 }
 
+// TODO(beng): provide a way to terminate an application.
 TEST_F(ViewManagerTest, DISABLED_ViewManagerDestroyed_CleanupNode) {
   ViewTreeNode* node1 = CreateNodeInParent(view_manager_1()->tree());
   WaitForTreeSizeToMatch(view_manager_2()->tree(), 2);
 
   TransportNodeId id = node1->id();
   DestroyViewManager1();
   std::set<TransportNodeId> nodes;
   nodes.insert(id);
   WaitForDestruction(view_manager_2(), &nodes, NULL);
 
   // tree() should still be valid, since it's owned by neither connection.
   EXPECT_TRUE(view_manager_2()->tree()->children().empty());
 }
 
-TEST_F(ViewManagerTest, DISABLED_SetActiveView) {
-  ViewTreeNode* node1 = CreateNodeInParent(view_manager_1()->tree());
-  WaitForTreeSizeToMatch(view_manager_2()->tree(), 2);
+TEST_F(ViewManagerTest, SetActiveView) {
+  ViewTreeNode* node = ViewTreeNode::Create(window_manager());
+  window_manager()->tree()->AddChild(node);
+  ViewManager* embedded = Embed(window_manager(), node);
 
-  View* view1 = View::Create(view_manager_1());
-  node1->SetActiveView(view1);
+  View* view = View::Create(window_manager());
+  node->SetActiveView(view);
 
-  ViewTreeNode* node1_2 = view_manager_2()->tree()->GetChildById(node1->id());
-  WaitForActiveViewToChange(node1_2);
+  ViewTreeNode* node_in_embedded = embedded->GetNodeById(node->id());
+  WaitForActiveViewToChange(node_in_embedded);
 
-  EXPECT_EQ(node1_2->active_view()->id(), view1->id());
+  EXPECT_EQ(node_in_embedded->active_view()->id(), view->id());
 }
 
-TEST_F(ViewManagerTest, DISABLED_DestroyView) {
-  ViewTreeNode* node1 = CreateNodeInParent(view_manager_1()->tree());
-  WaitForTreeSizeToMatch(view_manager_2()->tree(), 2);
+TEST_F(ViewManagerTest, DestroyView) {
+  ViewTreeNode* node = ViewTreeNode::Create(window_manager());
+  window_manager()->tree()->AddChild(node);
+  ViewManager* embedded = Embed(window_manager(), node);
 
-  View* view1 = View::Create(view_manager_1());
-  node1->SetActiveView(view1);
+  View* view = View::Create(window_manager());
+  node->SetActiveView(view);
 
-  ViewTreeNode* node1_2 = view_manager_2()->tree()->GetChildById(node1->id());
-  WaitForActiveViewToChange(node1_2);
+  ViewTreeNode* node_in_embedded = embedded->GetNodeById(node->id());
+  WaitForActiveViewToChange(node_in_embedded);
 
-  TransportViewId view1_id = view1->id();
-  view1->Destroy();
+  EXPECT_EQ(node_in_embedded->active_view()->id(), view->id());
+
+  TransportViewId view_id = view->id();
+  view->Destroy();
 
   std::set<TransportViewId> views;
-  views.insert(view1_id);
-  WaitForDestruction(view_manager_2(), NULL, &views);
-  EXPECT_EQ(NULL, node1_2->active_view());
-  EXPECT_EQ(NULL, view_manager_2()->GetViewById(view1_id));
+  views.insert(view_id);
+  WaitForDestruction(embedded, NULL, &views);
+  EXPECT_EQ(NULL, node_in_embedded->active_view());
+  EXPECT_EQ(NULL, embedded->GetViewById(view_id));
 }
 
 // Destroying the connection that created a node and view should result in that
 // node and view disappearing from all connections that see them.
 TEST_F(ViewManagerTest, DISABLED_ViewManagerDestroyed_CleanupNodeAndView) {
   ViewTreeNode* node1 = CreateNodeInParent(view_manager_1()->tree());
   WaitForTreeSizeToMatch(view_manager_2()->tree(), 2);
 
   View* view1 = View::Create(view_manager_1());
   node1->SetActiveView(view1);
@@ skipping 49 matching lines @@
   // disconnected from the node tree.
   View* another_view1_2 = view_manager_2()->GetViewById(view1_2_id);
   EXPECT_EQ(view1_2, another_view1_2);
   EXPECT_EQ(NULL, view1_2->node());
 }
 
 // This test verifies that it is not possible to set the active view to a view
 // defined in a different connection.
 // TODO(beng): write these tests for ViewTreeNode::AddChild(), RemoveChild() and
 //             Contains().
-TEST_F(ViewManagerTest, DISABLED_SetActiveViewAcrossConnection) {
-  ViewTreeNode* node1 = CreateNodeInParent(view_manager_1()->tree());
-  WaitForTreeSizeToMatch(view_manager_2()->tree(), 2);
+TEST_F(ViewManagerTest, SetActiveViewAcrossConnection) {
+  ViewTreeNode* node = ViewTreeNode::Create(window_manager());
+  window_manager()->tree()->AddChild(node);
+  ViewManager* embedded = Embed(window_manager(), node);
 
-  View* view1_2 = View::Create(view_manager_2());
-  EXPECT_DEATH(node1->SetActiveView(view1_2), "");
+  View* view_in_embedded = View::Create(embedded);
+  EXPECT_DEATH(node->SetActiveView(view_in_embedded), "");
 }
 
 // This test verifies that a node hierarchy constructed in one connection
 // becomes entirely visible to the second connection when the hierarchy is
 // attached.
-TEST_F(ViewManagerTest, DISABLED_MapSubtreeOnAttach) {
-  ViewTreeNode* node1 = ViewTreeNode::Create(view_manager_1());
-  ViewTreeNode* node11 = CreateNodeInParent(node1);
-  View* view11 = View::Create(view_manager_1());
-  node11->SetActiveView(view11);
-  gfx::Rect node11_bounds(800, 600);
-  node11->SetBounds(node11_bounds);
-  WaitForAllChangesToBeAcked(view_manager_1());
+TEST_F(ViewManagerTest, MapSubtreeOnAttach) {
+  ViewTreeNode* node = ViewTreeNode::Create(window_manager());
+  window_manager()->tree()->AddChild(node);
+  ViewManager* embedded = Embed(window_manager(), node);
 
-  // Now attach this node tree to the root & wait for it to show up in the
-  // second connection.
-  view_manager_1()->tree()->AddChild(node1);
-  WaitForTreeSizeToMatch(view_manager_2()->tree(), 3);
+  // Create a subtree private to the window manager and make some changes to it.
+  ViewTreeNode* child1 = ViewTreeNode::Create(window_manager());
+  ViewTreeNode* child11 = ViewTreeNode::Create(window_manager());
+  child1->AddChild(child11);
+  gfx::Rect child11_bounds(800, 600);
+  child11->SetBounds(child11_bounds);
+  View* view11 = View::Create(window_manager());
+  child11->SetActiveView(view11);
+  WaitForAllChangesToBeAcked(window_manager());
 
-  ViewTreeNode* node11_2 = view_manager_2()->GetNodeById(node11->id());
-  View* view11_2 = view_manager_2()->GetViewById(view11->id());
-  EXPECT_TRUE(node11_2 != NULL);
-  EXPECT_EQ(view11_2, node11_2->active_view());
-  EXPECT_EQ(node11_bounds, node11_2->bounds());
+  // When added to the shared node, the entire hierarchy and all property
+  // changes should become visible to the embedded app.
+  node->AddChild(child1);
+  WaitForTreeSizeToMatch(embedded->tree(), 3);
+
+  ViewTreeNode* child11_in_embedded = embedded->GetNodeById(child11->id());
+  View* view11_in_embedded = embedded->GetViewById(view11->id());
+  EXPECT_TRUE(child11_in_embedded != NULL);
+  EXPECT_EQ(view11_in_embedded, child11_in_embedded->active_view());
+  EXPECT_EQ(child11_bounds, child11_in_embedded->bounds());
 }
 
 // Verifies that bounds changes applied to a node hierarchy in one connection
 // are reflected to another.
-TEST_F(ViewManagerTest, DISABLED_SetBounds) {
-  ViewTreeNode* node1 = CreateNodeInParent(view_manager_1()->tree());
-  WaitForTreeSizeToMatch(view_manager_2()->tree(), 2);
+TEST_F(ViewManagerTest, SetBounds) {
+  ViewTreeNode* node = ViewTreeNode::Create(window_manager());
+  window_manager()->tree()->AddChild(node);
+  ViewManager* embedded = Embed(window_manager(), node);
 
-  ViewTreeNode* node1_2 = view_manager_2()->GetNodeById(node1->id());
-  EXPECT_EQ(node1->bounds(), node1_2->bounds());
+  ViewTreeNode* node_in_embedded = embedded->GetNodeById(node->id());
+  EXPECT_EQ(node->bounds(), node_in_embedded->bounds());
 
-  node1->SetBounds(gfx::Rect(0, 0, 100, 100));
-  WaitForBoundsToChange(node1_2);
-  EXPECT_EQ(node1->bounds(), node1_2->bounds());
+  node->SetBounds(gfx::Rect(100, 100));
+  EXPECT_NE(node->bounds(), node_in_embedded->bounds());
+  WaitForBoundsToChange(node_in_embedded);
+  EXPECT_EQ(node->bounds(), node_in_embedded->bounds());
 }
 
 // Verifies that bounds changes applied to a node owned by a different
 // connection are refused.
-TEST_F(ViewManagerTest, DISABLED_SetBoundsSecurity) {
-  ViewTreeNode* node1 = CreateNodeInParent(view_manager_1()->tree());
-  node1->SetBounds(gfx::Rect(800, 600));
-  WaitForTreeSizeToMatch(view_manager_2()->tree(), 2);
+TEST_F(ViewManagerTest, SetBoundsSecurity) {
+  ViewTreeNode* node = ViewTreeNode::Create(window_manager());
+  window_manager()->tree()->AddChild(node);
+  ViewManager* embedded = Embed(window_manager(), node);
 
-  ViewTreeNode* node1_2 = view_manager_2()->GetNodeById(node1->id());
-  node1_2->SetBounds(gfx::Rect(1024, 768));
+  ViewTreeNode* node_in_embedded = embedded->GetNodeById(node->id());
+  node->SetBounds(gfx::Rect(800, 600));
+  WaitForBoundsToChange(node_in_embedded);
+
+  node_in_embedded->SetBounds(gfx::Rect(1024, 768));
   // Bounds change should have been rejected.
-  EXPECT_EQ(node1->bounds(), node1_2->bounds());
+  EXPECT_EQ(node->bounds(), node_in_embedded->bounds());
 }
 
 // Verifies that a node can only be destroyed by the connection that created it.
-TEST_F(ViewManagerTest, DISABLED_DestroySecurity) {
-  ViewTreeNode* node1 = CreateNodeInParent(view_manager_1()->tree());
-  WaitForTreeSizeToMatch(view_manager_2()->tree(), 2);
+TEST_F(ViewManagerTest, DestroySecurity) {
+  ViewTreeNode* node = ViewTreeNode::Create(window_manager());
+  window_manager()->tree()->AddChild(node);
+  ViewManager* embedded = Embed(window_manager(), node);
 
-  ViewTreeNode* node1_2 = view_manager_2()->GetNodeById(node1->id());
-  NodeTracker tracker2(node1_2);
-  node1_2->Destroy();
+  ViewTreeNode* node_in_embedded = embedded->GetNodeById(node->id());
+
+  NodeTracker tracker2(node_in_embedded);
+  node_in_embedded->Destroy();
   // Node should not have been destroyed.
   EXPECT_TRUE(tracker2.is_valid());
 
-  NodeTracker tracker1(node1);
-  node1->Destroy();
+  NodeTracker tracker1(node);
+  node->Destroy();
   EXPECT_FALSE(tracker1.is_valid());
 }
 
 }  // namespace view_manager
 }  // namespace mojo