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

mojo/services/public/cpp/view_manager/lib/view_manager_client_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/public/cpp/view_manager/lib/view_manager_client_impl.h"
 
 #include "base/bind.h"
 #include "base/message_loop/message_loop.h"
 #include "base/stl_util.h"
 #include "mojo/public/cpp/application/application_connection.h"
 #include "mojo/public/cpp/application/connect.h"
+#include "mojo/public/cpp/application/exported_service_registry.h"
+#include "mojo/public/interfaces/application/service_provider.mojom.h"
 #include "mojo/services/public/cpp/view_manager/lib/node_private.h"
 #include "mojo/services/public/cpp/view_manager/lib/view_private.h"
 #include "mojo/services/public/cpp/view_manager/node_observer.h"
 #include "mojo/services/public/cpp/view_manager/util.h"
 #include "mojo/services/public/cpp/view_manager/view_manager_delegate.h"
 #include "mojo/services/public/cpp/view_manager/view_observer.h"
 #include "mojo/services/public/cpp/view_manager/window_manager_delegate.h"
 #include "third_party/skia/include/core/SkBitmap.h"
 #include "ui/gfx/codec/png_codec.h"
 
 namespace mojo {
 
 Id MakeTransportId(ConnectionSpecificId connection_id,
                    ConnectionSpecificId local_id) {
   return (connection_id << 16) | local_id;
 }
 
 // Helper called to construct a local node/view object from transport data.
 Node* AddNodeToViewManager(ViewManagerClientImpl* client,
                            Node* parent,
                            Id node_id,
                            Id view_id,
                            const gfx::Rect& bounds) {
   // We don't use the ctor that takes a ViewManager here, since it will call
   // back to the service and attempt to create a new node.
   Node* node = NodePrivate::LocalCreate();
   NodePrivate private_node(node);
   private_node.set_view_manager(client);
   private_node.set_id(node_id);
+  client->AddNode(node);
   private_node.LocalSetBounds(gfx::Rect(), bounds);
   if (parent)
     NodePrivate(parent).LocalAddChild(node);
-  client->AddNode(node);
 
   // View.
   if (view_id != 0) {
     View* view = ViewPrivate::LocalCreate();
     ViewPrivate private_view(view);
     private_view.set_view_manager(client);
     private_view.set_id(view_id);
     private_view.set_node(node);
+    client->AddView(view);
     // TODO(beng): this broadcasts notifications locally... do we want this? I
     //             don't think so. same story for LocalAddChild above!
     private_node.LocalSetActiveView(view);
-    client->AddView(view);
   }
   return node;
 }
 
 Node* BuildNodeTree(ViewManagerClientImpl* client,
                     const Array<NodeDataPtr>& nodes,
                     Node* initial_parent) {
   std::vector<Node*> parents;
   Node* root = NULL;
   Node* last_node = NULL;
@@ skipping 187 matching lines @@
   DCHECK(connected_);
   service_->SetFocus(node_id, ActionCompletedCallback());
 }
 
 void ViewManagerClientImpl::SetVisible(Id node_id, bool visible) {
   DCHECK(connected_);
   service_->SetNodeVisibility(node_id, visible, ActionCompletedCallback());
 }
 
 void ViewManagerClientImpl::Embed(const String& url, Id node_id) {
+  ServiceProviderPtr sp;
+  BindToProxy(new ExportedServiceRegistry, &sp);
+  Embed(url, node_id, sp.Pass());
+}
+
+void ViewManagerClientImpl::Embed(
+    const String& url,
+    Id node_id,
+    ServiceProviderPtr service_provider) {
   DCHECK(connected_);
-  service_->Embed(url, node_id, ActionCompletedCallback());
+  service_->Embed(url, node_id, service_provider.Pass(),
+                  ActionCompletedCallback());
 }
 
 void ViewManagerClientImpl::AddNode(Node* node) {
   DCHECK(nodes_.find(node->id()) == nodes_.end());
   nodes_[node->id()] = node;
 }
 
 void ViewManagerClientImpl::RemoveNode(Id node_id) {
   IdToNodeMap::iterator it = nodes_.find(node_id);
   if (it != nodes_.end())
@@ skipping 46 matching lines @@
 ////////////////////////////////////////////////////////////////////////////////
 // ViewManagerClientImpl, InterfaceImpl overrides:
 
 void ViewManagerClientImpl::OnConnectionEstablished() {
   service_ = client();
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // ViewManagerClientImpl, ViewManagerClient implementation:
 
-void ViewManagerClientImpl::OnEmbed(ConnectionSpecificId connection_id,
-                                    const String& creator_url,
-                                    NodeDataPtr root) {
+void ViewManagerClientImpl::OnEmbed(
+    ConnectionSpecificId connection_id,
+    const String& creator_url,
+    NodeDataPtr root_data,
+    InterfaceRequest<ServiceProvider> service_provider) {
   if (!connected_) {
     connected_ = true;
     connection_id_ = connection_id;
     creator_url_ = TypeConverter<String, std::string>::ConvertFrom(creator_url);
   } else {
     DCHECK_EQ(connection_id_, connection_id);
     DCHECK_EQ(creator_url_, creator_url);
   }
-  AddRoot(AddNodeToViewManager(this, NULL, root->node_id, root->view_id,
-                               root->bounds.To<gfx::Rect>()));
+
+  // A new root must not already exist as a root or be contained by an existing
+  // hierarchy visible to this view manager.
+  Node* root = AddNodeToViewManager(this, NULL, root_data->node_id,
+                                    root_data->view_id,
+                                    root_data->bounds.To<gfx::Rect>());
+  std::vector<Node*>::const_iterator it = roots_.begin();
+  for (; it != roots_.end(); ++it) {
+    if (*it == root || (*it)->Contains(root))
+      return;

[sky, 2014/07/31 21:14:11]

Do we ever really hit this?

+  }
+  roots_.push_back(root);
+  root->AddObserver(new RootObserver(root));
+
+  // BindToRequest() binds the lifetime of |exported_services| to the pipe.
+  ExportedServiceRegistry* exported_services = new ExportedServiceRegistry;
+  BindToRequest(exported_services, &service_provider);
+  RemoteServiceProvider* remote =
+      new RemoteServiceProvider(exported_services->client());
+  exported_services->set_remote(remote);
+  delegate_->OnEmbed(this, root, exported_services,
+                     scoped_ptr<ServiceProvider>(remote).Pass());
 }
 
 void ViewManagerClientImpl::OnNodeBoundsChanged(Id node_id,
                                                 RectPtr old_bounds,
                                                 RectPtr new_bounds) {
   Node* node = GetNodeById(node_id);
   NodePrivate(node).LocalSetBounds(old_bounds.To<gfx::Rect>(),
                                    new_bounds.To<gfx::Rect>());
 }
 
@@ skipping 78 matching lines @@
                       *NodePrivate(blurred).observers(),
                       OnNodeFocusChanged(focused, blurred));
   }
   if (focused) {
     FOR_EACH_OBSERVER(NodeObserver,
                       *NodePrivate(focused).observers(),
                       OnNodeFocusChanged(focused, blurred));
   }
 }
 
-void ViewManagerClientImpl::Embed(const String& url) {
-  window_manager_delegate_->Embed(url);
+void ViewManagerClientImpl::Embed(
+    const String& url,
+    InterfaceRequest<ServiceProvider> service_provider) {
+  window_manager_delegate_->Embed(url, service_provider.Pass());
 }
 
 void ViewManagerClientImpl::DispatchOnViewInputEvent(Id view_id,
                                                      EventPtr event) {
   window_manager_delegate_->DispatchEvent(GetViewById(view_id), event.Pass());
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // ViewManagerClientImpl, private:
 
-void ViewManagerClientImpl::AddRoot(Node* root) {
-  // A new root must not already exist as a root or be contained by an existing
-  // hierarchy visible to this view manager.
-  std::vector<Node*>::const_iterator it = roots_.begin();
-  for (; it != roots_.end(); ++it) {
-    if (*it == root || (*it)->Contains(root))
-      return;
-  }
-  roots_.push_back(root);
-  root->AddObserver(new RootObserver(root));
-  delegate_->OnEmbed(this, root);
-}
-
 void ViewManagerClientImpl::RemoveRoot(Node* root) {
   std::vector<Node*>::iterator it =
       std::find(roots_.begin(), roots_.end(), root);
   if (it != roots_.end())
     roots_.erase(it);
 }
 
 void ViewManagerClientImpl::OnActionCompleted(bool success) {
   if (!change_acked_callback_.is_null())
     change_acked_callback_.Run();
 }
 
 void ViewManagerClientImpl::OnActionCompletedWithErrorCode(ErrorCode code) {
   OnActionCompleted(code == ERROR_CODE_NONE);
 }
 
 base::Callback<void(bool)> ViewManagerClientImpl::ActionCompletedCallback() {
   return base::Bind(&ViewManagerClientImpl::OnActionCompleted,
                     base::Unretained(this));
 }
 
 base::Callback<void(ErrorCode)>
     ViewManagerClientImpl::ActionCompletedCallbackWithErrorCode() {
   return base::Bind(&ViewManagerClientImpl::OnActionCompletedWithErrorCode,
                     base::Unretained(this));
 }
 
 }  // namespace mojo