Deletion/ownership

mojo/services/public/cpp/view_manager/lib/view_manager_synchronizer.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/lib/view_manager_synchronizer.h"
 
 #include "base/bind.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "mojo/public/cpp/bindings/allocation_scope.h"
@@ skipping 167 matching lines @@
 
   DISALLOW_COPY_AND_ASSIGN(HierarchyTransaction);
 };
 
 ViewManagerSynchronizer::ViewManagerSynchronizer(ViewManager* view_manager)
     : view_manager_(view_manager),
       connected_(false),
       connection_id_(0),
       next_id_(1),
       next_change_id_(0),
+      sync_factory_(this),
       init_loop_(NULL) {
   InterfacePipe<services::view_manager::IViewManager, AnyInterface>
       view_manager_pipe;
   AllocationScope scope;
   MessagePipeHandle client_handle = view_manager_pipe.handle_to_peer.get();
   ViewManagerPrivate(view_manager_).shell()->Connect(
       "mojo:mojo_view_manager", view_manager_pipe.handle_to_peer.Pass());
   service_.reset(view_manager_pipe.handle_to_self.Pass(), this);
   service_->GetNodeTree(
       1,
       base::Bind(&ViewManagerSynchronizer::OnRootTreeReceived,
                  base::Unretained(this)));
   base::RunLoop loop;
   init_loop_ = &loop;
   init_loop_->Run();
   init_loop_ = NULL;
 }
 
 ViewManagerSynchronizer::~ViewManagerSynchronizer() {
+  DoSync();
 }
 
 TransportNodeId ViewManagerSynchronizer::CreateViewTreeNode() {
   DCHECK(connected_);
   uint16_t id = ++next_id_;
   pending_transactions_.push_back(new CreateViewTreeNodeTransaction(id, this));
   ScheduleSync();
   return MakeTransportNodeId(connection_id_, id);
 }
 
@@ skipping 19 matching lines @@
                                           TransportNodeId parent_id) {
   DCHECK(connected_);
   pending_transactions_.push_back(
       new HierarchyTransaction(HierarchyTransaction::TYPE_REMOVE,
                                child_id,
                                parent_id,
                                this));
   ScheduleSync();
 }
 
+bool ViewManagerSynchronizer::OwnsNode(TransportNodeId id) const {
+  return HiWord(id) == connection_id_;
+}
+
 ////////////////////////////////////////////////////////////////////////////////
 // ViewManagerSynchronizer, IViewManagerClient implementation:
 
 void ViewManagerSynchronizer::OnConnectionEstablished(uint16 connection_id) {
   connected_ = true;
   connection_id_ = connection_id;
   ScheduleSync();
 }
 
 void ViewManagerSynchronizer::OnNodeHierarchyChanged(uint32_t node_id,
                                                      uint32_t new_parent_id,
                                                      uint32_t old_parent_id,
                                                      uint32_t change_id) {
   if (change_id == 0) {
-    ViewTreeNode* new_parent =
-        view_manager_->tree()->GetChildById(new_parent_id);
-    ViewTreeNode* old_parent =
-        view_manager_->tree()->GetChildById(old_parent_id);
+    ViewTreeNode* new_parent = view_manager_->GetNodeById(new_parent_id);
+    ViewTreeNode* old_parent = view_manager_->GetNodeById(old_parent_id);
     ViewTreeNode* node = NULL;
     if (old_parent) {
       // Existing node, mapped in this connection's tree.
       // TODO(beng): verify this is actually true.
-      node = view_manager_->tree()->GetChildById(node_id);
+      node = view_manager_->GetNodeById(node_id);
       DCHECK_EQ(node->parent(), old_parent);
     } else {
       // New node, originating from another connection.
-      node = new ViewTreeNode;
+      node = ViewTreeNodePrivate::LocalCreate();
       ViewTreeNodePrivate private_node(node);
       private_node.set_view_manager(view_manager_);
       private_node.set_id(node_id);
+      ViewManagerPrivate(view_manager_).AddNode(node->id(), node);
     }
-    ViewTreeNodePrivate(new_parent).LocalAddChild(node);
+    if (new_parent)
+      ViewTreeNodePrivate(new_parent).LocalAddChild(node);
+    else
+      ViewTreeNodePrivate(old_parent).LocalRemoveChild(node);
   }
 }
 
 void ViewManagerSynchronizer::OnNodeViewReplaced(uint32_t node,
                                                  uint32_t new_view_id,
                                                  uint32_t old_view_id,
                                                  uint32_t change_id) {
   // ..
 }
 
+void ViewManagerSynchronizer::OnNodeDeleted(uint32_t node_id,
+                                            uint32_t change_id) {
+  if (change_id == 0) {
+    ViewTreeNode* node = view_manager_->GetNodeById(node_id);
+    if (node)
+      ViewTreeNodePrivate(node).LocalDestroy();
+  }
+}
+
 ////////////////////////////////////////////////////////////////////////////////
 // ViewManagerSynchronizer, private:
 
 void ViewManagerSynchronizer::ScheduleSync() {
+  if (sync_factory_.HasWeakPtrs())
+    return;
   base::MessageLoop::current()->PostTask(
       FROM_HERE,
-      base::Bind(&ViewManagerSynchronizer::DoSync, base::Unretained(this)));
+      base::Bind(&ViewManagerSynchronizer::DoSync, sync_factory_.GetWeakPtr()));
 }
 
 void ViewManagerSynchronizer::DoSync() {
   // The service connection may not be set up yet. OnConnectionEstablished()
   // will schedule another sync when it is.
   if (!connected_)
     return;
 
   Transactions::const_iterator it = pending_transactions_.begin();
   for (; it != pending_transactions_.end(); ++it) {
@@ skipping 24 matching lines @@
   ViewTreeNode* last_node = NULL;
   for (size_t i = 0; i < nodes.size(); ++i) {
     if (last_node && nodes[i].parent_id() == last_node->id()) {
       parents.push_back(last_node);
     } else if (!parents.empty()) {
       while (parents.back()->id() != nodes[i].parent_id())
         parents.pop_back();
     }
     // We don't use the ctor that takes a ViewManager here, since it will call
     // back to the service and attempt to create a new node.
-    ViewTreeNode* node = new ViewTreeNode;
+    ViewTreeNode* node = ViewTreeNodePrivate::LocalCreate();
     ViewTreeNodePrivate private_node(node);
     private_node.set_view_manager(view_manager_);
     private_node.set_id(nodes[i].node_id());
     if (!parents.empty())
       ViewTreeNodePrivate(parents.back()).LocalAddChild(node);
     if (!last_node)
       root = node;
     last_node = node;
+    ViewManagerPrivate(view_manager_).AddNode(node->id(), node);
   }
-  ViewManagerPrivate(view_manager_).SetRoot(root);
+  ViewManagerPrivate(view_manager_).set_root(root);
   if (init_loop_)
     init_loop_->Quit();
 }
 
 }  // namespace view_manager
 }  // namespace services
 }  // namespace mojo