Pass ServiceProvider thru ViewManagerService::Embed() allowing embedder & embeddee to expose servic…

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"
 #include "mojo/services/view_manager/node.h"
 #include "mojo/services/view_manager/root_node_manager.h"
 #include "mojo/services/view_manager/view.h"
 #include "mojo/services/view_manager/window_manager_access_policy.h"
 #include "third_party/skia/include/core/SkBitmap.h"
 #include "ui/aura/window.h"
 #include "ui/gfx/codec/png_codec.h"
 
 namespace mojo {
 namespace service {
 
 ViewManagerServiceImpl::ViewManagerServiceImpl(
     RootNodeManager* root_node_manager,
     ConnectionSpecificId creator_id,
     const std::string& creator_url,
     const std::string& url,
-    const NodeId& root_id)
+    const NodeId& root_id,
+    InterfaceRequest<ServiceProvider> service_provider)
     : 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) {
+      delete_on_connection_error_(false),
+      service_provider_(service_provider.Pass()) {
   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));
 }
 
 ViewManagerServiceImpl::~ViewManagerServiceImpl() {
   // Delete any views we created.
@@ skipping 238 matching lines @@
     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], local_nodes);
 }
 
-void ViewManagerServiceImpl::AddRoot(const NodeId& node_id) {
+void ViewManagerServiceImpl::AddRoot(
+    const NodeId& node_id,
+    InterfaceRequest<ServiceProvider> service_provider) {
   const Id transport_node_id(NodeIdToTransportId(node_id));
   CHECK(roots_.count(transport_node_id) == 0);
 
   CHECK_EQ(creator_id_, node_id.connection_id);
   roots_.insert(transport_node_id);
   const Node* node = GetNode(node_id);
   CHECK(node);
   std::vector<const Node*> to_send;
   if (!IsNodeKnown(node)) {
     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()->OnEmbed(id_, creator_url_, NodeToNodeData(to_send.front()));
+  client()->OnEmbed(id_, creator_url_, NodeToNodeData(to_send.front()),
+                    service_provider.Pass());
   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);
 
   // No need to do anything if we created the node.
@@ skipping 244 matching lines @@
   const bool success = node && node->IsVisible() != visible &&
       access_policy_->CanChangeNodeVisibility(node);
   if (success) {
     DCHECK(node);
     node->SetVisible(visible);
   }
   // 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) {
+void ViewManagerServiceImpl::Embed(
+    const String& url,
+    Id transport_node_id,
+    ServiceProviderPtr service_provider,
+    const Callback<void(bool)>& callback) {
+  InterfaceRequest<ServiceProvider> spir;
+  spir.Bind(service_provider.PassMessagePipe());
+
   if (NodeIdFromTransportId(transport_node_id) == InvalidNodeId()) {
-    root_node_manager_->EmbedRoot(url);
+    root_node_manager_->EmbedRoot(url, spir.Pass());
     callback.Run(true);
     return;
   }
   const Node* node = GetNode(NodeIdFromTransportId(transport_node_id));
   bool success = node && access_policy_->CanEmbed(node);
   if (success) {
     // 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>());
     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_, true);
       RemoveChildrenAsPartOfEmbed(node_id);
       // 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);
+      if (connection_by_url) {
+        connection_by_url->AddRoot(node_id, spir.Pass());
+      } else {
+        root_node_manager_->Embed(id_, url, transport_node_id,
+                                  spir.Pass());
+      }
     } 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
@@ skipping 12 matching lines @@
   }
 }
 
 void ViewManagerServiceImpl::OnConnectionEstablished() {
   root_node_manager_->AddConnection(this);
 
   std::vector<const Node*> to_send;
   for (NodeIdSet::const_iterator i = roots_.begin(); i != roots_.end(); ++i)
     GetUnknownNodesFrom(GetNode(NodeIdFromTransportId(*i)), &to_send);
 
-  client()->OnEmbed(id_, creator_url_, NodeToNodeData(to_send.front()));
+  client()->OnEmbed(id_, creator_url_, NodeToNodeData(to_send.front()),
+                    service_provider_.Pass());
 }
 
 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