Deletion/ownership

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/bind.h"
 #include "base/logging.h"
 #include "mojo/services/public/cpp/view_manager/lib/view_tree_node_private.h"
 #include "mojo/services/public/cpp/view_manager/util.h"
@@ skipping 13 matching lines @@
   current_run_loop->Run();
   current_run_loop = NULL;
 }
 
 void QuitRunLoop() {
   current_run_loop->Quit();
 }
 
 // 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) {}
 
  protected:
   ViewManager* view_manager_1() { return view_manager_1_.get(); }
   ViewManager* view_manager_2() { return view_manager_2_.get(); }
 
-  scoped_ptr<ViewTreeNode> CreateNodeInParent(ViewTreeNode* parent) {
+  ViewTreeNode* CreateNodeInParent(ViewTreeNode* parent) {
     ViewManager* parent_manager = ViewTreeNodePrivate(parent).view_manager();
-    scoped_ptr<ViewTreeNode> node(new ViewTreeNode(parent_manager));
-    parent->AddChild(node.get());
-    return node.Pass();
+    ViewTreeNode* node = ViewTreeNode::Create(parent_manager);
+    parent->AddChild(node);
+    return node;
+  }
+
+  void DestroyViewManager1() {
+    view_manager_1_.reset();
   }
 
  private:
   // Overridden from testing::Test:
   virtual void SetUp() OVERRIDE {
     test_helper_.Init();
     view_manager_1_.reset(new ViewManager(test_helper_.shell()));
     view_manager_2_.reset(new ViewManager(test_helper_.shell()));
     view_manager_1_->Init();
     view_manager_2_->Init();
@@ skipping 21 matching lines @@
   }
 
  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 (params.phase != ViewTreeNodeObserver::DISPOSITION_CHANGED)
-      return;
     if (ShouldQuitRunLoop(params))
       QuitRunLoop();
   }
 
   ViewManager* view_manager_;
   DISALLOW_COPY_AND_ASSIGN(TreeObserverBase);
 };
 
 // Spins a runloop until the tree beginning at |root| has |tree_size| nodes
 // (including |root|).
 class TreeSizeMatchesWaiter : public TreeObserverBase {
  public:
   TreeSizeMatchesWaiter(ViewManager* view_manager, size_t tree_size)
       : TreeObserverBase(view_manager),
         tree_size_(tree_size) {
     DoRunLoop();
   }
   virtual ~TreeSizeMatchesWaiter() {}
 
  private:
   // Overridden from TreeObserverBase:
   virtual bool ShouldQuitRunLoop(const TreeChangeParams& params) OVERRIDE {
+    if (params.phase != ViewTreeNodeObserver::DISPOSITION_CHANGED)
+      return false;
     return CountNodes(view_manager()->tree()) == tree_size_;
   }
 
   size_t CountNodes(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;
   }
 
   size_t tree_size_;
   DISALLOW_COPY_AND_ASSIGN(TreeSizeMatchesWaiter);
 };
 
 
 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);
 };
 
 TEST_F(ViewManagerTest, HierarchyChanged_NodeCreated) {
   HierarchyChanged_NodeCreatedObserver observer(view_manager_2());
-  scoped_ptr<ViewTreeNode> node1(new ViewTreeNode(view_manager_1()));
-  view_manager_1()->tree()->AddChild(node1.get());
+  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());
 }
 
 // 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() {}
 
  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_;
   }
 
   TransportNodeId old_parent_id_;
   TransportNodeId new_parent_id_;
 
   DISALLOW_COPY_AND_ASSIGN(HierarchyChanged_NodeMovedObserver);
 };
 
 TEST_F(ViewManagerTest, HierarchyChanged_NodeMoved) {
-  scoped_ptr<ViewTreeNode> node1(CreateNodeInParent(view_manager_1()->tree()));
-  scoped_ptr<ViewTreeNode> node2(CreateNodeInParent(view_manager_1()->tree()));
-  scoped_ptr<ViewTreeNode> node21(CreateNodeInParent(node2.get()));
+  ViewTreeNode* node1 = CreateNodeInParent(view_manager_1()->tree());
+  ViewTreeNode* node2 = CreateNodeInParent(view_manager_1()->tree());
+  ViewTreeNode* node21 = CreateNodeInParent(node2);
   TreeSizeMatchesWaiter waiter(view_manager_2(), 4);
 
   HierarchyChanged_NodeMovedObserver observer(view_manager_2(),
                                               node2->id(),
                                               node1->id());
 
-  node1->AddChild(node21.get());
+  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);
 }
 
-// TODO(beng): node destruction
+class HierarchyChanged_NodeRemovedObserver : public TreeObserverBase {
+ public:
+  HierarchyChanged_NodeRemovedObserver(ViewManager* view_manager)
+      : TreeObserverBase(view_manager) {}
+  virtual ~HierarchyChanged_NodeRemovedObserver() {}
+
+ 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;
+  }
+
+  DISALLOW_COPY_AND_ASSIGN(HierarchyChanged_NodeRemovedObserver);
+};
+
+TEST_F(ViewManagerTest, HierarchyChanged_NodeRemoved) {
+  ViewTreeNode* node1 = CreateNodeInParent(view_manager_1()->tree());
+  TreeSizeMatchesWaiter waiter(view_manager_2(), 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());
+}
+
+class NodeDestroyed_Waiter : public ViewTreeNodeObserver {
+ public:
+  NodeDestroyed_Waiter(ViewManager* view_manager, TransportNodeId id)
+      : view_manager_(view_manager),
+        id_(id) {
+    view_manager_->GetNodeById(id)->AddObserver(this);
+    DoRunLoop();
+  }
+  virtual ~NodeDestroyed_Waiter() {
+  }
+
+ private:
+  // Overridden from TreeObserverBase:
+  virtual void OnNodeDestroy(ViewTreeNode* node,
+                             DispositionChangePhase phase) OVERRIDE {
+    if (phase != DISPOSITION_CHANGED)
+      return;
+    if (node->id() == id_)
+      QuitRunLoop();
+  }
+
+  TransportNodeId id_;
+  ViewManager* view_manager_;
+
+  DISALLOW_COPY_AND_ASSIGN(NodeDestroyed_Waiter);
+};
+
+TEST_F(ViewManagerTest, NodeDestroyed) {
+  ViewTreeNode* node1 = CreateNodeInParent(view_manager_1()->tree());
+  TreeSizeMatchesWaiter init_waiter(view_manager_2(), 2);
+
+  // |node1| will be deleted after calling Destroy() below.
+  TransportNodeId id = node1->id();
+  node1->Destroy();
+  NodeDestroyed_Waiter destroyed_waiter(view_manager_2(), id);
+
+  EXPECT_TRUE(view_manager_2()->tree()->children().empty());
+}
+
+TEST_F(ViewManagerTest, ViewManagerDestroyed) {
+  ViewTreeNode* node1 = CreateNodeInParent(view_manager_1()->tree());
+  TreeSizeMatchesWaiter init_waiter(view_manager_2(), 2);
+
+  TransportNodeId id = node1->id();
+  DestroyViewManager1();
+  NodeDestroyed_Waiter destroyed_waiter(view_manager_2(), id);
+
+  // tree() should still be valid, since it's owned by neither connection.
+  EXPECT_TRUE(view_manager_2()->tree()->children().empty());
+}
 
 }  // namespace view_manager
 }  // namespace services
 }  // namespace mojo