Makes it so a node can only the root of one connection at a time

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 68 matching lines @@
 }
 
 const View* ViewManagerServiceImpl::GetView(const ViewId& id) const {
   if (id_ == id.connection_id) {
     ViewMap::const_iterator i = view_map_.find(id.view_id);
     return i == view_map_.end() ? NULL : i->second;
   }
   return root_node_manager_->GetView(id);
 }
 
+bool ViewManagerServiceImpl::HasRoot(const NodeId& id) const {
+  return roots_.find(NodeIdToTransportId(id)) != roots_.end();
+}
+
 void ViewManagerServiceImpl::OnViewManagerServiceImplDestroyed(
     ConnectionSpecificId id) {
   if (creator_id_ == id)
     creator_id_ = kRootConnection;
 }
 
 void ViewManagerServiceImpl::ProcessNodeBoundsChanged(
     const Node* node,
     const gfx::Rect& old_bounds,
     const gfx::Rect& new_bounds,
@@ skipping 13 matching lines @@
     const Node* new_parent,
     const Node* old_parent,
     Id server_change_id,
     bool originated_change) {
   if (known_nodes_.count(NodeIdToTransportId(node->id())) > 0) {
     if (originated_change)
       return;
     if (node->id().connection_id != id_ && !IsNodeDescendantOfRoots(node)) {
       // Node was a descendant of roots and is no longer, treat it as though the
       // node was deleted.
-      RemoveFromKnown(node);
+      RemoveFromKnown(node, NULL);
       client()->OnNodeDeleted(NodeIdToTransportId(node->id()),
                               server_change_id);
       root_node_manager_->OnConnectionMessagedClient(id_);
       return;
     }
   }
 
   if (originated_change || root_node_manager_->is_processing_delete_node())
     return;
   std::vector<const Node*> to_send;
@@ skipping 267 matching lines @@
   const Id transport_id = NodeIdToTransportId(node->id());
   if (known_nodes_.count(transport_id) == 1)
     return;
   nodes->push_back(node);
   known_nodes_.insert(transport_id);
   std::vector<const Node*> children(node->GetChildren());
   for (size_t i = 0 ; i < children.size(); ++i)
     GetUnknownNodesFrom(children[i], nodes);
 }
 
-void ViewManagerServiceImpl::RemoveFromKnown(const Node* node) {
-  if (node->id().connection_id == id_)
+void ViewManagerServiceImpl::RemoveFromKnown(const Node* node,
+                                             std::vector<Node*>* local_nodes) {
+  if (node->id().connection_id == id_) {
+    if (local_nodes)
+      local_nodes->push_back(GetNode(node->id()));
     return;
+  }
   known_nodes_.erase(NodeIdToTransportId(node->id()));
   std::vector<const Node*> children = node->GetChildren();
   for (size_t i = 0; i < children.size(); ++i)
-    RemoveFromKnown(children[i]);
+    RemoveFromKnown(children[i], local_nodes);
 }
 
-bool ViewManagerServiceImpl::AddRoot(Id transport_node_id) {
-  if (roots_.count(transport_node_id) > 0)
-    return false;
+void ViewManagerServiceImpl::AddRoot(const NodeId& node_id) {
+  const Id transport_node_id(NodeIdToTransportId(node_id));
+  CHECK(roots_.count(transport_node_id) == 0);
 
   std::vector<const Node*> to_send;
-  const NodeId node_id(NodeIdFromTransportId(transport_node_id));
   CHECK_EQ(creator_id_, node_id.connection_id);
   roots_.insert(transport_node_id);
   Node* node = GetNode(node_id);
   CHECK(node);
   if (known_nodes_.count(transport_node_id) == 0) {
     GetUnknownNodesFrom(node, &to_send);
   } else {
     // Even though the connection knows about the new root we need to tell it
     // |node| is now a root.
     to_send.push_back(node);
   }
 
   client()->OnRootAdded(NodesToNodeDatas(to_send));
-  return true;
+  root_node_manager_->OnConnectionMessagedClient(id_);
+}
+
+void ViewManagerServiceImpl::RemoveRoot(const NodeId& node_id) {
+  const Id transport_node_id(NodeIdToTransportId(node_id));
+  CHECK(roots_.count(transport_node_id) > 0);
+
+  roots_.erase(transport_node_id);
+  if (roots_.empty())
+    roots_.insert(NodeIdToTransportId(InvalidNodeId()));
+
+  // No need to do anything if we created the node.
+  if (node_id.connection_id == id_)
+    return;
+
+  client()->OnNodeDeleted(transport_node_id,
+                          root_node_manager_->next_server_change_id());
+  root_node_manager_->OnConnectionMessagedClient(id_);
+
+  // This connection no longer knows about the node. Unparent any nodes that
+  // were parented to nodes in the root.
+  std::vector<Node*> local_nodes;
+  RemoveFromKnown(GetNode(node_id), &local_nodes);
+  for (size_t i = 0; i < local_nodes.size(); ++i)
+    local_nodes[i]->GetParent()->Remove(local_nodes[i]);
 }
 
 bool ViewManagerServiceImpl::IsNodeDescendantOfRoots(const Node* node) const {
   if (roots_.empty())
     return true;
   if (!node)
     return false;
   const Id invalid_node_id =
       NodeIdToTransportId(InvalidNodeId());
   for (NodeIdSet::const_iterator i = roots_.begin(); i != roots_.end(); ++i) {
@@ skipping 281 matching lines @@
   }
   // TODO(sky): need to notify of visibility changes.
   callback.Run(success);
 }
 
 void ViewManagerServiceImpl::Embed(const String& url,
                                    Id transport_node_id,
                                    const Callback<void(bool)>& callback) {
   bool success = CanEmbed(transport_node_id);
   if (success) {
-    // We may already have this connection, if so reuse it.
-    ViewManagerServiceImpl* existing_connection =
+    // Only allow a node to be the root for one connection.
+    const NodeId node_id(NodeIdFromTransportId(transport_node_id));
+    ViewManagerServiceImpl* connection_by_url =
         root_node_manager_->GetConnectionByCreator(id_, url.To<std::string>());
-    if (existing_connection)
-      success = existing_connection->AddRoot(transport_node_id);
-    else
-      root_node_manager_->Embed(id_, url, transport_node_id);
+    ViewManagerServiceImpl* connection_with_node_as_root =
+        root_node_manager_->GetConnectionWithRoot(node_id);
+    if ((connection_by_url != connection_with_node_as_root ||
+         (!connection_by_url && !connection_with_node_as_root)) &&
+        (!connection_by_url || !connection_by_url->HasRoot(node_id))) {
+      RootNodeManager::ScopedChange change(
+          this, root_node_manager_,
+          RootNodeManager::CHANGE_TYPE_ADVANCE_SERVER_CHANGE_ID, true);
+      // Never message the originating connection.
+      root_node_manager_->OnConnectionMessagedClient(id_);
+      if (connection_with_node_as_root)
+        connection_with_node_as_root->RemoveRoot(node_id);
+      if (connection_by_url)
+        connection_by_url->AddRoot(node_id);
+      else
+        root_node_manager_->Embed(id_, url, transport_node_id);
+      change.SendServerChangeIdAdvanced();
+    } else {
+      success = false;
+    }
   }
   callback.Run(success);
 }
 
 void ViewManagerServiceImpl::DispatchOnViewInputEvent(Id transport_view_id,
                                                       EventPtr event) {
   // We only allow the WM to dispatch events. At some point this function will
   // move to a separate interface and the check can go away.
   if (id_ != kWindowManagerConnection)
     return;
@@ skipping 23 matching lines @@
   client()->OnViewManagerConnectionEstablished(
       id_,
       creator_url_,
       root_node_manager_->next_server_change_id(),
       NodesToNodeDatas(to_send));
 }
 
 }  // namespace service
 }  // namespace view_manager
 }  // namespace mojo