Trigger Node destruction notifications from Node's dtor

mojo/services/view_manager/view_manager_service_impl.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/view_manager/view_manager_service_impl.h"
 
 #include "base/bind.h"
 #include "mojo/services/public/cpp/geometry/geometry_type_converters.h"
 #include "mojo/services/public/cpp/input_events/input_events_type_converters.h"
 #include "mojo/services/view_manager/node.h"
@@ skipping 29 matching lines @@
     const std::string& url)
     : root_node_manager_(root_node_manager),
       id_(root_node_manager_->GetAndAdvanceNextConnectionId()),
       url_(url),
       creator_id_(creator_id),
       creator_url_(creator_url),
       delete_on_connection_error_(false) {
 }
 
 ViewManagerServiceImpl::~ViewManagerServiceImpl() {
-  // Delete any views we own.
+  // Delete any views we created.
   while (!view_map_.empty()) {
     bool result = DeleteViewImpl(this, view_map_.begin()->second->id());
     DCHECK(result);
   }
 
-  // We're about to destroy all our nodes. Detach any views from them.
-  for (NodeMap::iterator i = node_map_.begin(); i != node_map_.end(); ++i) {
-    if (i->second->view()) {
-      bool result = SetViewImpl(i->second, ViewId());
-      DCHECK(result);
-    }
-  }
-
+  // Ditto the nodes.
   if (!node_map_.empty()) {
     RootNodeManager::ScopedChange change(
         this, root_node_manager_,
         RootNodeManager::CHANGE_TYPE_ADVANCE_SERVER_CHANGE_ID, true);
-    while (!node_map_.empty()) {
-      scoped_ptr<Node> node(node_map_.begin()->second);
-      Node* parent = node->GetParent();
-      const NodeId node_id(node->id());
-      if (parent)
-        parent->Remove(node.get());
-      root_node_manager_->ProcessNodeDeleted(node_id);
-      node_map_.erase(NodeIdToTransportId(node_id));
-    }
+    while (!node_map_.empty())
+      delete node_map_.begin()->second;
   }
 
   root_node_manager_->RemoveConnection(this);
 }
 
 const Node* ViewManagerServiceImpl::GetNode(const NodeId& id) const {
   if (id_ == id.connection_id) {
     NodeMap::const_iterator i = node_map_.find(id.node_id);
     return i == node_map_.end() ? NULL : i->second;
   }
@@ skipping 111 matching lines @@
       ViewIdToTransportId(new_view->id()) : 0;
   const Id old_view_id = old_view ?
       ViewIdToTransportId(old_view->id()) : 0;
   client()->OnNodeViewReplaced(NodeIdToTransportId(node->id()),
                                new_view_id, old_view_id);
 }
 
 void ViewManagerServiceImpl::ProcessNodeDeleted(const NodeId& node,
                                                 Id server_change_id,
                                                 bool originated_change) {
+  node_map_.erase(node.node_id);
+
   const bool in_known = known_nodes_.erase(NodeIdToTransportId(node)) > 0;
   const bool in_roots = roots_.erase(NodeIdToTransportId(node)) > 0;
 
   if (in_roots && roots_.empty())
     roots_.insert(NodeIdToTransportId(InvalidNodeId()));
 
   if (originated_change)
     return;
 
   if (in_known) {
@@ skipping 157 matching lines @@
 
 bool ViewManagerServiceImpl::DeleteNodeImpl(ViewManagerServiceImpl* source,
                                             const NodeId& node_id) {
   DCHECK_EQ(node_id.connection_id, id_);
   Node* node = GetNode(node_id);
   if (!node)
     return false;
   RootNodeManager::ScopedChange change(
       source, root_node_manager_,
       RootNodeManager::CHANGE_TYPE_ADVANCE_SERVER_CHANGE_ID, true);
-  if (node->GetParent())
-    node->GetParent()->Remove(node);
-  std::vector<Node*> children(node->GetChildren());
-  for (size_t i = 0; i < children.size(); ++i)
-    node->Remove(children[i]);
-  DCHECK(node->GetChildren().empty());
-  node_map_.erase(node_id.node_id);
   delete node;
-  node = NULL;
-  root_node_manager_->ProcessNodeDeleted(node_id);
   return true;
 }
 
 bool ViewManagerServiceImpl::DeleteViewImpl(ViewManagerServiceImpl* source,
                                             const ViewId& view_id) {
   DCHECK_EQ(view_id.connection_id, id_);
   View* view = GetView(view_id);
   if (!view)
     return false;
   RootNodeManager::ScopedChange change(
@@ skipping 158 matching lines @@
 
 void ViewManagerServiceImpl::CreateNode(
     Id transport_node_id,
     const Callback<void(bool)>& callback) {
   const NodeId node_id(NodeIdFromTransportId(transport_node_id));
   if (node_id.connection_id != id_ ||
       node_map_.find(node_id.node_id) != node_map_.end()) {
     callback.Run(false);
     return;
   }
-  node_map_[node_id.node_id] = new Node(this, node_id);
+  node_map_[node_id.node_id] = new Node(root_node_manager_, node_id);
   known_nodes_.insert(transport_node_id);
   callback.Run(true);
 }
 
 void ViewManagerServiceImpl::DeleteNode(
     Id transport_node_id,
     Id server_change_id,
     const Callback<void(bool)>& callback) {
   const NodeId node_id(NodeIdFromTransportId(transport_node_id));
   bool success = false;
@@ skipping 211 matching lines @@
   ViewManagerServiceImpl* connection = root_node_manager_->GetConnection(
       view_id.connection_id);
   if (connection) {
     connection->client()->OnViewInputEvent(
         transport_view_id,
         event.Pass(),
         base::Bind(&base::DoNothing));
   }
 }
 
-void ViewManagerServiceImpl::OnNodeHierarchyChanged(const Node* node,
-                                                    const Node* new_parent,
-                                                    const Node* old_parent) {
-  root_node_manager_->ProcessNodeHierarchyChanged(node, new_parent, old_parent);
-}
-
-void ViewManagerServiceImpl::OnNodeBoundsChanged(const Node* node,
-                                                 const gfx::Rect& old_bounds,
-                                                 const gfx::Rect& new_bounds) {
-  root_node_manager_->ProcessNodeBoundsChanged(node, old_bounds, new_bounds);
-}
-
-void ViewManagerServiceImpl::OnNodeViewReplaced(const Node* node,
-                                                const View* new_view,
-                                                const View* old_view) {
-  root_node_manager_->ProcessNodeViewReplaced(node, new_view, old_view);
-}
-
-void ViewManagerServiceImpl::OnViewInputEvent(const View* view,
-                                              const ui::Event* event) {
-  root_node_manager_->DispatchViewInputEventToWindowManager(view, event);
-}
-
 void ViewManagerServiceImpl::OnConnectionEstablished() {
   root_node_manager_->AddConnection(this);
 
   std::vector<const Node*> to_send;
   if (roots_.empty()) {
     GetUnknownNodesFrom(root_node_manager_->root(), &to_send);
   } else {
     for (NodeIdSet::const_iterator i = roots_.begin(); i != roots_.end(); ++i)
       GetUnknownNodesFrom(GetNode(NodeIdFromTransportId(*i)), &to_send);
   }
 
   client()->OnViewManagerConnectionEstablished(
       id_,
       creator_url_,
       root_node_manager_->next_server_change_id(),
       NodesToNodeDatas(to_send));
 }
 
 }  // namespace service
 }  // namespace view_manager
 }  // namespace mojo