Makes Embed() take a single node

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 19 matching lines @@
   for (size_t i = 0 ; i < children.size(); ++i)
     GetDescendants(children[i], nodes);
 }
 
 }  // namespace
 
 ViewManagerServiceImpl::ViewManagerServiceImpl(
     RootNodeManager* root_node_manager,
     ConnectionSpecificId creator_id,
     const std::string& creator_url,
-    const std::string& 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) {
+  if (root_id != InvalidNodeId()) {
+    CHECK(GetNode(root_id));
+    roots_.insert(NodeIdToTransportId(root_id));
+  }
 }
 
 ViewManagerServiceImpl::~ViewManagerServiceImpl() {
   // Delete any views we created.
   while (!view_map_.empty()) {
     bool result = DeleteViewImpl(this, view_map_.begin()->second->id());
     DCHECK(result);
   }
 
   // Ditto the nodes.
@@ skipping 17 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);
 }
 
-void ViewManagerServiceImpl::SetRoots(const Array<Id>& node_ids) {
-  DCHECK(roots_.empty());
-  NodeIdSet roots;
-  for (size_t i = 0; i < node_ids.size(); ++i) {
-    DCHECK(GetNode(NodeIdFromTransportId(node_ids[i])));
-    roots.insert(node_ids[i]);
-  }
-  roots_.swap(roots);
-}
-
 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 232 matching lines @@
 bool ViewManagerServiceImpl::CanSetFocus(const Node* node) const {
   // TODO(beng): security.
   return true;
 }
 
 bool ViewManagerServiceImpl::CanGetNodeTree(const Node* node) const {
   return node &&
       (IsNodeDescendantOfRoots(node) || node->id().connection_id == id_);
 }
 
-bool ViewManagerServiceImpl::CanEmbed(
-    const mojo::Array<uint32_t>& node_ids) const {
-  for (size_t i = 0; i < node_ids.size(); ++i) {
-    const Node* node = GetNode(NodeIdFromTransportId(node_ids[i]));
-    if (!node || node->id().connection_id != id_)
-      return false;
-  }
-  return node_ids.size() > 0;
+bool ViewManagerServiceImpl::CanEmbed(Id transport_node_id) const {
+  const Node* node = GetNode(NodeIdFromTransportId(transport_node_id));
+  return node && node->id().connection_id == id_;
 }
 
 bool ViewManagerServiceImpl::CanSetNodeVisibility(const Node* node,
                                                   bool visibile) const {
   return node &&
       (node->id().connection_id == id_ ||
        roots_.find(NodeIdToTransportId(node->id())) != roots_.end()) &&
       node->IsVisible() != visibile;
 }
 
@@ skipping 55 matching lines @@
 
 void ViewManagerServiceImpl::RemoveFromKnown(const Node* node) {
   if (node->id().connection_id == 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]);
 }
 
-bool ViewManagerServiceImpl::AddRoots(
-    const std::vector<Id>& node_ids) {
+bool ViewManagerServiceImpl::AddRoot(Id transport_node_id) {
+  if (roots_.count(transport_node_id) > 0)
+    return false;
+
   std::vector<const Node*> to_send;
-  bool did_add_root = false;
-  for (size_t i = 0; i < node_ids.size(); ++i) {
-    CHECK_EQ(creator_id_, NodeIdFromTransportId(node_ids[i]).connection_id);
-    if (roots_.count(node_ids[i]) > 0)
-      continue;
-
-    did_add_root = true;
-    roots_.insert(node_ids[i]);
-    Node* node = GetNode(NodeIdFromTransportId(node_ids[i]));
-    DCHECK(node);
-    if (known_nodes_.count(node_ids[i]) == 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);
-    }
+  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);
   }
 
-  if (!did_add_root)
-    return false;
-
-  client()->OnRootsAdded(NodesToNodeDatas(to_send));
+  client()->OnRootAdded(NodesToNodeDatas(to_send));
   return true;
 }
 
 bool ViewManagerServiceImpl::IsNodeDescendantOfRoots(const Node* node) const {
   if (roots_.empty())
     return true;
   if (!node)
     return false;
   const Id invalid_node_id =
       NodeIdToTransportId(InvalidNodeId());
@@ skipping 278 matching lines @@
   const bool success = CanSetNodeVisibility(node, visible);
   if (success) {
     DCHECK(node);
     node->SetVisible(visible);
   }
   // TODO(sky): need to notify of visibility changes.
   callback.Run(success);
 }
 
 void ViewManagerServiceImpl::Embed(const String& url,
-                                   Array<uint32_t> node_ids,
+                                   Id transport_node_id,
                                    const Callback<void(bool)>& callback) {
-  bool success = CanEmbed(node_ids);
+  bool success = CanEmbed(transport_node_id);
   if (success) {
     // We may already have this connection, if so reuse it.
     ViewManagerServiceImpl* existing_connection =
         root_node_manager_->GetConnectionByCreator(id_, url.To<std::string>());
     if (existing_connection)
-      success = existing_connection->AddRoots(node_ids.storage());
+      success = existing_connection->AddRoot(transport_node_id);
     else
-      root_node_manager_->Embed(id_, url, node_ids);
+      root_node_manager_->Embed(id_, url, transport_node_id);
   }
   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