Trigger Node destruction notifications from Node's dtor

mojo/services/view_manager/root_node_manager.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/root_node_manager.h"
 
 #include "base/logging.h"
 #include "mojo/public/cpp/application/application_connection.h"
 #include "mojo/public/interfaces/service_provider/service_provider.mojom.h"
 #include "mojo/services/public/cpp/input_events/input_events_type_converters.h"
@@ skipping 30 matching lines @@
 RootNodeManager::Context::~Context() {
   aura::Env::DeleteInstance();
 }
 
 RootNodeManager::RootNodeManager(ApplicationConnection* app_connection,
                                  RootViewManagerDelegate* view_manager_delegate)
     : app_connection_(app_connection),
       next_connection_id_(1),
       next_server_change_id_(1),
       root_view_manager_(app_connection, this, view_manager_delegate),
-      root_(this, RootNodeId()),
+      root_(new Node(this, RootNodeId())),
       current_change_(NULL) {
 }
 
 RootNodeManager::~RootNodeManager() {
   aura::client::FocusClient* focus_client =
-      aura::client::GetFocusClient(root_.window());
+      aura::client::GetFocusClient(root_->window());
   focus_client->RemoveObserver(this);
   while (!connections_created_by_connect_.empty())
     delete *(connections_created_by_connect_.begin());
   // All the connections should have been destroyed.
   DCHECK(connection_map_.empty());
+  root_.reset();
 }
 
 ConnectionSpecificId RootNodeManager::GetAndAdvanceNextConnectionId() {
   const ConnectionSpecificId id = next_connection_id_++;
   DCHECK_LT(id, next_connection_id_);
   return id;
 }
 
 void RootNodeManager::AddConnection(ViewManagerServiceImpl* connection) {
   DCHECK_EQ(0u, connection_map_.count(connection->id()));
@@ skipping 24 matching lines @@
   EmbedImpl(creator_id, url, node_ids)->set_delete_on_connection_error();
 }
 
 ViewManagerServiceImpl* RootNodeManager::GetConnection(
     ConnectionSpecificId connection_id) {
   ConnectionMap::iterator i = connection_map_.find(connection_id);
   return i == connection_map_.end() ? NULL : i->second;
 }
 
 Node* RootNodeManager::GetNode(const NodeId& id) {
-  if (id == root_.id())
-    return &root_;
+  if (id == root_->id())
+    return root_.get();
   ConnectionMap::iterator i = connection_map_.find(id.connection_id);
   return i == connection_map_.end() ? NULL : i->second->GetNode(id);
 }
 
 View* RootNodeManager::GetView(const ViewId& id) {
   ConnectionMap::iterator i = connection_map_.find(id.connection_id);
   return i == connection_map_.end() ? NULL : i->second->GetView(id);
 }
 
 void RootNodeManager::OnConnectionMessagedClient(ConnectionSpecificId id) {
@@ skipping 69 matching lines @@
        i != connection_map_.end(); ++i) {
     i->second->ProcessNodeViewReplaced(node, new_view, old_view,
                                        IsChangeSource(i->first));
   }
 }
 
 void RootNodeManager::ProcessNodeDeleted(const NodeId& node) {
   for (ConnectionMap::iterator i = connection_map_.begin();
        i != connection_map_.end(); ++i) {
     i->second->ProcessNodeDeleted(node, next_server_change_id_,
-                                 IsChangeSource(i->first));
+                                  IsChangeSource(i->first));
   }
 }
 
 void RootNodeManager::ProcessViewDeleted(const ViewId& view) {
   for (ConnectionMap::iterator i = connection_map_.begin();
        i != connection_map_.end(); ++i) {
     i->second->ProcessViewDeleted(view, IsChangeSource(i->first));
   }
 }
 
@@ skipping 34 matching lines @@
       ViewManagerServiceImpl::Client::Name_,
       pipe.handle1.Pass());
 
   std::string creator_url;
   ConnectionMap::const_iterator it = connection_map_.find(creator_id);
   if (it != connection_map_.end())
     creator_url = it->second->url();
 
   ViewManagerServiceImpl* connection =
       new ViewManagerServiceImpl(this,
-                                creator_id,
-                                creator_url,
-                                url.To<std::string>());
+                                 creator_id,
+                                 creator_url,
+                                 url.To<std::string>());
   connection->SetRoots(node_ids);
   BindToPipe(connection, pipe.handle0.Pass());
   connections_created_by_connect_.insert(connection);
   return connection;
 }
 
+void RootNodeManager::OnNodeDestroyed(const Node* node) {
+  ProcessNodeDeleted(node->id());
+}
+
 void RootNodeManager::OnNodeHierarchyChanged(const Node* node,
                                              const Node* new_parent,
                                              const Node* old_parent) {
   if (!root_view_manager_.in_setup())
     ProcessNodeHierarchyChanged(node, new_parent, old_parent);
 }
 
 void RootNodeManager::OnNodeBoundsChanged(const Node* node,
                                           const gfx::Rect& old_bounds,
                                           const gfx::Rect& new_bounds) {
   ProcessNodeBoundsChanged(node, old_bounds, new_bounds);
 }
 
 void RootNodeManager::OnNodeViewReplaced(const Node* node,
                                          const View* new_view,
                                          const View* old_view) {
   ProcessNodeViewReplaced(node, new_view, old_view);
 }
 
 void RootNodeManager::OnViewInputEvent(const View* view,
                                        const ui::Event* event) {
   DispatchViewInputEventToWindowManager(view, event);
 }
 
 }  // namespace service
 }  // namespace view_manager
 }  // namespace mojo