Finishes up setroots

mojo/services/view_manager/view_manager_connection.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_connection.h"
 
 #include "base/stl_util.h"
 #include "mojo/public/cpp/bindings/allocation_scope.h"
 #include "mojo/services/view_manager/node.h"
 #include "mojo/services/view_manager/root_node_manager.h"
@@ skipping 29 matching lines @@
 ViewManagerConnection::~ViewManagerConnection() {
   // Delete any views we own.
   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->id(), ViewId());
+      bool result = SetViewImpl(i->second, ViewId());
       DCHECK(result);
     }
   }
 
-  STLDeleteContainerPairSecondPointers(node_map_.begin(), node_map_.end());
+  if (!node_map_.empty()) {
+    RootNodeManager::ScopedChange change(
+        this, root_node_manager_,
+        RootNodeManager::CHANGE_TYPE_ADVANCE_SERVER_CHANGE_ID, true);
+    while (!node_map_.empty()) {
+      Node* node = node_map_.begin()->second;
+      Node* parent = node->GetParent();
+      const NodeId node_id(node->id());
+      if (parent)
+        parent->Remove(node);
+      root_node_manager_->ProcessNodeDeleted(node_id);
+      node_map_.erase(NodeIdToTransportId(node_id));
+    }
+  }
+
   root_node_manager_->RemoveConnection(this);
 }
 
 void ViewManagerConnection::OnConnectionEstablished() {
   DCHECK_EQ(0, id_);  // Should only get OnConnectionEstablished() once.
   id_ = root_node_manager_->GetAndAdvanceNextConnectionId();
   root_node_manager_->AddConnection(this);
   std::vector<const Node*> to_send;
   GetUnknownNodesFrom(root_node_manager_->root(), &to_send);
   AllocationScope allocation_scope;
   client()->OnConnectionEstablished(
       id_,
       root_node_manager_->next_server_change_id(),
       NodesToINodes(to_send));
 }
 
 const Node* ViewManagerConnection::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;
   }
   return root_node_manager_->GetNode(id);
 }
 
-View* ViewManagerConnection::GetView(const ViewId& id) {
+const View* ViewManagerConnection::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);
 }
 
 void ViewManagerConnection::ProcessNodeHierarchyChanged(
     const Node* node,
     const Node* new_parent,
@@ skipping 51 matching lines @@
       ViewIdToTransportId(old_view->id()) : 0;
   client()->OnNodeViewReplaced(NodeIdToTransportId(node->id()),
                                new_view_id, old_view_id);
 }
 
 void ViewManagerConnection::ProcessNodeDeleted(
     const NodeId& node,
     TransportChangeId server_change_id,
     bool originated_change) {
   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) {
     client()->OnNodeDeleted(NodeIdToTransportId(node), server_change_id);
   } else if (root_node_manager_->IsProcessingChange()) {
     client()->OnServerChangeIdAdvanced(
         root_node_manager_->next_server_change_id() + 1);
   }
 }
 
 void ViewManagerConnection::ProcessViewDeleted(const ViewId& view,
                                                bool originated_change) {
   if (originated_change)
     return;
   client()->OnViewDeleted(ViewIdToTransportId(view));
 }
 
+bool ViewManagerConnection::CanRemoveNodeFromParent(const Node* node) const {
+  if (!node)
+    return false;
+
+  const Node* parent = node->GetParent();
+  if (!parent)
+    return false;
+
+  // Always allow the remove if there are no roots. Otherwise the remove is
+  // allowed if the parent is a descendant of the roots, or the node and its
+  // parent were created by this connection. We explicitly disallow removal of
+  // the node from its parent if the parent isn't visible to this connection
+  // (not in roots).
+  return (roots_.empty() ||
+          (IsNodeDescendantOfRoots(parent) ||
+           (node->id().connection_id == id_ &&
+            parent->id().connection_id == id_)));
+}
+
+bool ViewManagerConnection::CanAddNode(const Node* parent,
+                                       const Node* child) const {
+  if (!parent || !child)
+    return false;  // Both nodes must be valid.
+
+  if (child->GetParent() == parent || child->Contains(parent))
+    return false;  // Would result in an invalid hierarchy.
+
+  if (roots_.empty())
+    return true;  // No restriction if there are no roots.
+
+  if (!IsNodeDescendantOfRoots(parent) && parent->id().connection_id != id_)
+    return false;  // |parent| is not visible to this connection.
+
+  // Allow the add if the child is already a descendant of the roots or was
+  // created by this connection.
+  return (IsNodeDescendantOfRoots(child) || child->id().connection_id == id_);
+}
+
 bool ViewManagerConnection::CanDeleteNode(const NodeId& node_id) const {
   return node_id.connection_id == id_;
 }
 
 bool ViewManagerConnection::CanDeleteView(const ViewId& view_id) const {
   return view_id.connection_id == id_;
 }
 
+bool ViewManagerConnection::CanSetView(const Node* node,
+                                       const ViewId& view_id) const {
+  if (!node || !IsNodeDescendantOfRoots(node))
+    return false;
+
+  const View* view = GetView(view_id);
+  return (view && view_id.connection_id == id_) || view_id == ViewId();
+}
+
+bool ViewManagerConnection::CanGetNodeTree(const Node* node) const {
+  return node &&
+      (IsNodeDescendantOfRoots(node) || node->id().connection_id == id_);
+}
+
 bool ViewManagerConnection::DeleteNodeImpl(ViewManagerConnection* 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())
@@ skipping 22 matching lines @@
     view->node()->SetView(NULL);
   view_map_.erase(view_id.view_id);
   // Make a copy of |view_id| as once we delete view |view_id| may no longer be
   // valid.
   const ViewId view_id_copy(view_id);
   delete view;
   root_node_manager_->ProcessViewDeleted(view_id_copy);
   return true;
 }
 
-bool ViewManagerConnection::SetViewImpl(const NodeId& node_id,
-                                        const ViewId& view_id) {
-  Node* node = GetNode(node_id);
-  if (!node)
-    return false;
+bool ViewManagerConnection::SetViewImpl(Node* node, const ViewId& view_id) {
+  DCHECK(node);  // CanSetView() should have verified node exists.
   View* view = GetView(view_id);
-  if (!view && view_id != ViewId())
-    return false;
   RootNodeManager::ScopedChange change(
       this, root_node_manager_,
       RootNodeManager::CHANGE_TYPE_DONT_ADVANCE_SERVER_CHANGE_ID, false);
   node->SetView(view);
   return true;
 }
 
 void ViewManagerConnection::GetUnknownNodesFrom(
     const Node* node,
     std::vector<const Node*>* nodes) {
@@ skipping 14 matching lines @@
   std::vector<const Node*> children = node->GetChildren();
   for (size_t i = 0; i < children.size(); ++i)
     RemoveFromKnown(children[i]);
 }
 
 bool ViewManagerConnection::IsNodeDescendantOfRoots(const Node* node) const {
   if (roots_.empty())
     return true;
   if (!node)
     return false;
+  const TransportNodeId invalid_node_id =
+      NodeIdToTransportId(InvalidNodeId());
   for (NodeIdSet::const_iterator i = roots_.begin(); i != roots_.end(); ++i) {
+    if (*i == invalid_node_id)
+      continue;
     const Node* root = GetNode(NodeIdFromTransportId(*i));
     DCHECK(root);
     if (root->Contains(node))
       return true;
   }
   return false;
 }
 
 bool ViewManagerConnection::ShouldNotifyOnHierarchyChange(
     const Node* node,
@@ skipping 126 matching lines @@
 
 void ViewManagerConnection::AddNode(
     TransportNodeId parent_id,
     TransportNodeId child_id,
     TransportChangeId server_change_id,
     const Callback<void(bool)>& callback) {
   bool success = false;
   if (server_change_id == root_node_manager_->next_server_change_id()) {
     Node* parent = GetNode(NodeIdFromTransportId(parent_id));
     Node* child = GetNode(NodeIdFromTransportId(child_id));
-    if (parent && child && child->GetParent() != parent &&
-        !child->window()->Contains(parent->window())) {
+    if (CanAddNode(parent, child)) {
       success = true;
       RootNodeManager::ScopedChange change(
           this, root_node_manager_,
           RootNodeManager::CHANGE_TYPE_ADVANCE_SERVER_CHANGE_ID, false);
       parent->Add(child);
     }
   }
   callback.Run(success);
 }
 
 void ViewManagerConnection::RemoveNodeFromParent(
     TransportNodeId node_id,
     TransportChangeId server_change_id,
     const Callback<void(bool)>& callback) {
   bool success = false;
   if (server_change_id == root_node_manager_->next_server_change_id()) {
     Node* node = GetNode(NodeIdFromTransportId(node_id));
-    if (node && node->GetParent()) {
+    if (CanRemoveNodeFromParent(node)) {
       success = true;
       RootNodeManager::ScopedChange change(
           this, root_node_manager_,
           RootNodeManager::CHANGE_TYPE_ADVANCE_SERVER_CHANGE_ID, false);
       node->GetParent()->Remove(node);
     }
   }
   callback.Run(success);
 }
 
 void ViewManagerConnection::GetNodeTree(
     TransportNodeId node_id,
     const Callback<void(Array<INode>)>& callback) {
   AllocationScope allocation_scope;
   Node* node = GetNode(NodeIdFromTransportId(node_id));
   std::vector<const Node*> nodes;
-  GetDescendants(node, &nodes);
-  for (size_t i = 0; i < nodes.size(); ++i)
-    known_nodes_.insert(NodeIdToTransportId(nodes[i]->id()));
+  if (CanGetNodeTree(node)) {
+    GetDescendants(node, &nodes);
+    for (size_t i = 0; i < nodes.size(); ++i)
+      known_nodes_.insert(NodeIdToTransportId(nodes[i]->id()));
+  }
   callback.Run(NodesToINodes(nodes));
 }
 
 void ViewManagerConnection::CreateView(
     TransportViewId transport_view_id,
     const Callback<void(bool)>& callback) {
   const ViewId view_id(ViewIdFromTransportId(transport_view_id));
   if (view_id.connection_id != id_ || view_map_.count(view_id.view_id)) {
     callback.Run(false);
     return;
@@ skipping 12 matching lines @@
         view_id.connection_id);
     did_delete = (connection && connection->DeleteViewImpl(this, view_id));
   }
   callback.Run(did_delete);
 }
 
 void ViewManagerConnection::SetView(
     TransportNodeId transport_node_id,
     TransportViewId transport_view_id,
     const Callback<void(bool)>& callback) {
-  const NodeId node_id(NodeIdFromTransportId(transport_node_id));
-  callback.Run(SetViewImpl(node_id, ViewIdFromTransportId(transport_view_id)));
+  Node* node = GetNode(NodeIdFromTransportId(transport_node_id));
+  const ViewId view_id(ViewIdFromTransportId(transport_view_id));
+  callback.Run(CanSetView(node, view_id) && SetViewImpl(node, view_id));
 }
 
 void ViewManagerConnection::SetViewContents(
     TransportViewId view_id,
     ScopedSharedBufferHandle buffer,
     uint32_t buffer_size) {
   View* view = GetView(ViewIdFromTransportId(view_id));
   if (!view)
     return;
   void* handle_data;
@@ skipping 26 matching lines @@
 
 void ViewManagerConnection::OnNodeViewReplaced(const Node* node,
                                                const View* new_view,
                                                const View* old_view) {
   root_node_manager_->ProcessNodeViewReplaced(node, new_view, old_view);
 }
 
 }  // namespace service
 }  // namespace view_manager
 }  // namespace mojo