Cleans up usage of ViewManagerServiceImpl::roots_

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/default_access_policy.h"
@@ skipping 13 matching lines @@
     ConnectionSpecificId creator_id,
     const std::string& creator_url,
     const std::string& url,
     const NodeId& root_id)
     : 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) {
-  // TODO: http://crbug.com/397660 .
-  if (root_id != InvalidNodeId()) {
-    CHECK(GetNode(root_id));
-    roots_.insert(NodeIdToTransportId(root_id));
+  CHECK(GetNode(root_id));
+  roots_.insert(NodeIdToTransportId(root_id));
+  if (root_id == RootNodeId())
+    access_policy_.reset(new WindowManagerAccessPolicy(id_, this));
+  else
     access_policy_.reset(new DefaultAccessPolicy(id_, this));
-  } else {
-    access_policy_.reset(new WindowManagerAccessPolicy(id_, this));
-  }
 }
 
 ViewManagerServiceImpl::~ViewManagerServiceImpl() {
   // Delete any views we created.
   while (!view_map_.empty()) {
     bool result = DeleteViewImpl(this, view_map_.begin()->second);
     DCHECK(result);
   }
 
   // Ditto the nodes.
@@ skipping 22 matching lines @@
   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;
+    creator_id_ = kInvalidConnectionId;
 }
 
 void ViewManagerServiceImpl::ProcessNodeBoundsChanged(
     const Node* node,
     const gfx::Rect& old_bounds,
     const gfx::Rect& new_bounds,
     bool originated_change) {
   if (originated_change || !IsNodeKnown(node))
     return;
   client()->OnNodeBoundsChanged(NodeIdToTransportId(node->id()),
                                 Rect::From(old_bounds),
                                 Rect::From(new_bounds));
 }
 
 void ViewManagerServiceImpl::ProcessNodeHierarchyChanged(
     const Node* node,
     const Node* new_parent,
     const Node* old_parent,
     bool originated_change) {
+  if (originated_change && !IsNodeKnown(node) && new_parent &&
+      IsNodeKnown(new_parent)) {
+    std::vector<const Node*> unused;
+    GetUnknownNodesFrom(node, &unused);
+  }
   if (originated_change || root_node_manager_->is_processing_delete_node() ||
       root_node_manager_->DidConnectionMessageClient(id_)) {
     return;
   }
 
   if (!access_policy_->ShouldNotifyOnHierarchyChange(
           node, &new_parent, &old_parent)) {
     return;
   }
   // Inform the client of any new nodes and update the set of nodes we know
@@ skipping 37 matching lines @@
       access_policy_->GetViewIdToSend(node, old_view) : 0;
   client()->OnNodeViewReplaced(NodeIdToTransportId(node->id()),
                                new_view_id, old_view_id);
 }
 
 void ViewManagerServiceImpl::ProcessNodeDeleted(const NodeId& node,
                                                 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;
-
-  // TODO(sky): cleanup!
-  if (in_roots && roots_.empty())
-    roots_.insert(NodeIdToTransportId(InvalidNodeId()));
+  roots_.erase(NodeIdToTransportId(node));
 
   if (originated_change)
     return;
 
   if (in_known) {
     client()->OnNodeDeleted(NodeIdToTransportId(node));
     root_node_manager_->OnConnectionMessagedClient(id_);
   }
 }
 
@@ skipping 83 matching lines @@
 bool ViewManagerServiceImpl::SetViewImpl(Node* node, View* view) {
   DCHECK(node);  // CanSetView() should have verified node exists.
   RootNodeManager::ScopedChange change(this, root_node_manager_, false);
   node->SetView(view);
   return true;
 }
 
 void ViewManagerServiceImpl::GetUnknownNodesFrom(
     const Node* node,
     std::vector<const Node*>* nodes) {
-  if (IsNodeKnown(node))
+  if (IsNodeKnown(node) || !access_policy_->CanGetNodeTree(node))
     return;
   nodes->push_back(node);
   known_nodes_.insert(NodeIdToTransportId(node->id()));
+  if (!access_policy_->CanDescendIntoNodeForNodeTree(node))
+    return;
   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,
                                              std::vector<Node*>* local_nodes) {
   if (node->id().connection_id == id_) {
     if (local_nodes)
       local_nodes->push_back(GetNode(node->id()));
@@ skipping 24 matching lines @@
 
   client()->OnRootAdded(NodesToNodeDatas(to_send));
   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_->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]);
 }
 
 void ViewManagerServiceImpl::RemoveChildrenAsPartOfEmbed(
     const NodeId& node_id) {
-  // Let the root do what it wants.
-  if (roots_.empty())
-    return;
-
   Node* node = GetNode(node_id);
   CHECK(node);
   CHECK(node->id().connection_id == node_id.connection_id);
   std::vector<Node*> children = node->GetChildren();
   for (size_t i = 0; i < children.size(); ++i)
     node->Remove(children[i]);
 }
 
 Array<NodeDataPtr> ViewManagerServiceImpl::NodesToNodeDatas(
     const std::vector<const Node*>& nodes) {
@@ skipping 275 matching lines @@
         transport_view_id,
         event.Pass(),
         base::Bind(&base::DoNothing));
   }
 }
 
 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);
-  }
+  for (NodeIdSet::const_iterator i = roots_.begin(); i != roots_.end(); ++i)
+    GetUnknownNodesFrom(GetNode(NodeIdFromTransportId(*i)), &to_send);
 
   client()->OnViewManagerConnectionEstablished(
       id_,
       creator_url_,
       NodesToNodeDatas(to_send));
 }
 
 const base::hash_set<Id>&
 ViewManagerServiceImpl::GetRootsForAccessPolicy() const {
   return roots_;
 }
 
 bool ViewManagerServiceImpl::IsNodeKnownForAccessPolicy(
     const Node* node) const {
   return IsNodeKnown(node);
 }
 
 bool ViewManagerServiceImpl::IsNodeRootOfAnotherConnectionForAccessPolicy(
     const Node* node) const {
   ViewManagerServiceImpl* connection =
       root_node_manager_->GetConnectionWithRoot(node->id());
   return connection && connection != this;
 }
 
 }  // namespace service
 }  // namespace mojo