FrameMojoShell provides services to mojo apps.

content/browser/frame_host/frame_mojo_shell.cc

 // Copyright 2015 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 "content/browser/frame_host/frame_mojo_shell.h"
 
 #include "content/browser/mojo/mojo_shell_context.h"
+#include "content/common/mojo/service_registry_impl.h"
+#include "content/public/browser/content_browser_client.h"
 #include "content/public/browser/render_frame_host.h"
 #include "content/public/browser/site_instance.h"
+#include "content/public/common/content_client.h"
+#include "content/public/common/service_registry.h"
+#include "third_party/mojo/src/mojo/public/cpp/bindings/strong_binding.h"
 
 namespace content {
 
+namespace {
+
+// A ServiceProvider implementation based on ServiceRegistryImpl. Strongly bound

[Ken Rockot(use gerrit already), 2015/07/06 18:58:00]

I think this class might be unnecessary if FrameMojoShell hosts a
ServiceProviderImpl (see other comments).

[xhwang, 2015/07/07 19:21:04]

Removed in favor of WeakBindingSet.

+// to the ServiceProvider request.
+class ProxyServiceProvider : public mojo::ServiceProvider {
+ public:
+  ProxyServiceProvider(ServiceRegistryImpl* service_registry,
+                       mojo::InterfaceRequest<mojo::ServiceProvider> services)
+      : service_registry_(service_registry), binding_(this, services.Pass()){};
+  ~ProxyServiceProvider() final{};
+
+  // mojo::ServiceProvider implementation.
+  void ConnectToService(const mojo::String& interface_name,
+                        mojo::ScopedMessagePipeHandle pipe) final {
+    // Cast because ConnectToService() is private in ServiceRegistryImpl.
+    static_cast<mojo::ServiceProvider*>(service_registry_)
+        ->ConnectToService(interface_name.get(), pipe.Pass());
+  };
+
+ private:
+  ServiceRegistryImpl* service_registry_;
+  mojo::StrongBinding<ServiceProvider> binding_;
+};
+
+}  // namespace
+
 FrameMojoShell::FrameMojoShell(RenderFrameHost* frame_host)
     : frame_host_(frame_host) {
 }
 
 FrameMojoShell::~FrameMojoShell() {
 }
 
 void FrameMojoShell::BindRequest(
     mojo::InterfaceRequest<mojo::Shell> shell_request) {
   bindings_.AddBinding(this, shell_request.Pass());
 }
 
+// TODO(xhwang): Currently no callers are exposing |exposed_services|. So we
+// drop it and replace it with services we provide in the browser. In the
+// future we may need to support both.
 void FrameMojoShell::ConnectToApplication(
     mojo::URLRequestPtr application_url,
     mojo::InterfaceRequest<mojo::ServiceProvider> services,
-    mojo::ServiceProviderPtr exposed_services) {
+    mojo::ServiceProviderPtr /* exposed_services */) {
+  mojo::ServiceProviderPtr frame_services;
+  new ProxyServiceProvider(GetServiceRegistry(), GetProxy(&frame_services));

[Ken Rockot(use gerrit already), 2015/07/06 18:58:00]

Though it may be true in practice (and I may be missing something), I don't see
any reason why we can assume this won't outlive the frame host which owns the
ServiceRegistry, and that could be a problem.

If you go with the ServiceProviderImpl suggestion outlined in other comments, it
doesn't matter though, because FrameMojoHost can instead just own a
WeakBindingSet<mojo::ServiceProvider> and add new bindings to its
ServiceProviderImpl here.

[xhwang, 2015/07/07 19:21:04]

Use SRI + WBS now.

+
   MojoShellContext::ConnectToApplication(
       GURL(application_url->url), frame_host_->GetSiteInstance()->GetSiteURL(),
-      services.Pass());
+      services.Pass(), frame_services.Pass());
 }
 
 void FrameMojoShell::QuitApplication() {
 }
 
+ServiceRegistryImpl* FrameMojoShell::GetServiceRegistry() {
+  if (!service_registry_) {
+    service_registry_.reset(new ServiceRegistryImpl());
+
+    GetContentClient()->browser()->OverrideFrameMojoShellServices(
+        service_registry_.get(), frame_host_);
+  }
+
+  return service_registry_.get();
+}
+
 }  // namespace content