First cut at "content handling" support in Mojo.

mojo/service_manager/service_manager.cc

 // Copyright 2013 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/service_manager/service_manager.h"
+
 #include <stdio.h>
 
-#include "mojo/service_manager/service_manager.h"
-
+#include "base/bind.h"
 #include "base/lazy_instance.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/stl_util.h"
 #include "mojo/common/common_type_converters.h"
 #include "mojo/service_manager/service_loader.h"
+#include "mojo/services/public/interfaces/content_handler/content_handler.mojom.h"
 
 namespace mojo {
 
 namespace {
 // Used by TestAPI.
 bool has_created_instance = false;
 
 class StubServiceProvider : public InterfaceImpl<ServiceProvider> {
  public:
   ServiceProvider* GetRemoteServiceProvider() {
     return client();
   }
 
  private:
   virtual void ConnectToService(
       const String& service_name,
       ScopedMessagePipeHandle client_handle) MOJO_OVERRIDE {}
 };
 
-}
+}  // namespace
+
+class ServiceManager::LoadServiceCallbacksImpl
+    : public ServiceLoader::LoadServiceCallbacks {
+ public:
+  LoadServiceCallbacksImpl(base::WeakPtr<ServiceManager> manager,
+                           const GURL& requested_url,
+                           const GURL& requestor_url,
+                           ServiceProviderPtr service_provider)
+      : manager_(manager),
+        requested_url_(requested_url),
+        requestor_url_(requestor_url),
+        service_provider_(service_provider.Pass()) {
+  }
+
+ private:
+  virtual ~LoadServiceCallbacksImpl() {
+  }
+
+  // LoadServiceCallbacks implementation
+  virtual ScopedMessagePipeHandle RegisterApplication() OVERRIDE {
+    ScopedMessagePipeHandle shell_handle;
+    if (manager_) {
+      manager_->RegisterLoadedApplication(requested_url_,
+                                          requestor_url_,
+                                          service_provider_.Pass(),
+                                          &shell_handle);
+    }
+    return shell_handle.Pass();
+  }
+
+  virtual void LoadWithContentHandler(
+      const GURL& content_handler_url,
+      URLResponsePtr content) OVERRIDE {
+    if (manager_) {
+      manager_->LoadWithContentHandler(requested_url_,
+                                       requestor_url_,
+                                       content_handler_url,
+                                       content.Pass(),
+                                       service_provider_.Pass());
+    }
+  }
+
+  base::WeakPtr<ServiceManager> manager_;
+  GURL requested_url_;
+  GURL requestor_url_;
+  ServiceProviderPtr service_provider_;
+};
 
 class ServiceManager::ShellImpl : public InterfaceImpl<Shell> {
  public:
   ShellImpl(ServiceManager* manager, const GURL& url)
       : manager_(manager),
         url_(url) {
   }
 
   virtual ~ShellImpl() {
   }
@@ skipping 22 matching lines @@
   virtual void OnConnectionError() OVERRIDE {
     manager_->OnShellImplError(this);
   }
 
   ServiceManager* const manager_;
   const GURL url_;
 
   DISALLOW_COPY_AND_ASSIGN(ShellImpl);
 };
 
+struct ServiceManager::ContentHandlerConnection {
+  ContentHandlerConnection(ServiceManager* manager,
+                           const GURL& content_handler_url) {
+    ServiceProviderPtr service_provider;
+    BindToProxy(&service_provider_impl, &service_provider);
+    manager->ConnectToApplication(content_handler_url,
+                                  GURL(),
+                                  service_provider.Pass());
+    MessagePipe pipe;
+    content_handler.Bind(pipe.handle0.Pass());
+    service_provider_impl.client()->ConnectToService(ContentHandler::Name_,
+                                                     pipe.handle1.Pass());
+  }
+
+  StubServiceProvider service_provider_impl;
+  ContentHandlerPtr content_handler;
+};
+
 // static
 ServiceManager::TestAPI::TestAPI(ServiceManager* manager) : manager_(manager) {
 }
 
 ServiceManager::TestAPI::~TestAPI() {
 }
 
 bool ServiceManager::TestAPI::HasCreatedInstance() {
   return has_created_instance;
 }
 
 bool ServiceManager::TestAPI::HasFactoryForURL(const GURL& url) const {
   return manager_->url_to_shell_impl_.find(url) !=
          manager_->url_to_shell_impl_.end();
 }
 
-ServiceManager::ServiceManager() : interceptor_(NULL) {
+ServiceManager::ServiceManager()
+    : interceptor_(NULL),
+      weak_ptr_factory_(this) {
 }
 
 ServiceManager::~ServiceManager() {
+  STLDeleteValues(&url_to_content_handler_);

[tim (not reviewing), 2014/08/05 20:45:55]

Are connections you're adding here for content handlers still represented by a
ServiceManager::ShellImpl <> ApplicationImpl?  The idea with
TerminateShellConnections (and how it's used in
https://codereview.chromium.org/394903005/) is that the Application side watches
its ShellPtr for a pipe error to Quits itself.  TerminateShellConnections is
used (by tests as of that CL) to trigger that pipe error, and wait for KeepAlive
to notice that no connections remain and kill the shell loop. "no connections
remain" from KeepAlive's perspective right now means that the
keep_alive_counter() hits 0, which right now mostly translates to all of the
InProcessDynamicServiceRunners having completed / gone away.

[Aaron Boodman, 2014/08/05 22:45:34]

Yes, content handlers are also normal mojo applications, so they will show up in
url_to_shell_impl_. This map is just a cache of the ContentHandler interface.

   TerminateShellConnections();
   STLDeleteValues(&url_to_loader_);
   STLDeleteValues(&scheme_to_loader_);
 }
 
 void ServiceManager::TerminateShellConnections() {
   STLDeleteValues(&url_to_shell_impl_);
 }
 
 // static
 ServiceManager* ServiceManager::GetInstance() {
   static base::LazyInstance<ServiceManager> instance =
       LAZY_INSTANCE_INITIALIZER;
   has_created_instance = true;
   return &instance.Get();
 }
 
 void ServiceManager::ConnectToApplication(const GURL& url,
                                           const GURL& requestor_url,
                                           ServiceProviderPtr service_provider) {
   URLToShellImplMap::const_iterator shell_it = url_to_shell_impl_.find(url);
-  ShellImpl* shell_impl;
   if (shell_it != url_to_shell_impl_.end()) {
-    shell_impl = shell_it->second;
-  } else {
-    MessagePipe pipe;
-    GetLoaderForURL(url)->LoadService(this, url, pipe.handle0.Pass());
-    shell_impl = WeakBindToPipe(new ShellImpl(this, url), pipe.handle1.Pass());
-    url_to_shell_impl_[url] = shell_impl;
+    ConnectToClient(shell_it->second, url, requestor_url,
+                    service_provider.Pass());
+    return;
   }
+
+  scoped_refptr<LoadServiceCallbacksImpl> callbacks(
+      new LoadServiceCallbacksImpl(weak_ptr_factory_.GetWeakPtr(),
+                                   url,
+                                   requestor_url,
+                                   service_provider.Pass()));
+  GetLoaderForURL(url)->LoadService(this, url, callbacks);
+}
+
+void ServiceManager::ConnectToClient(ShellImpl* shell_impl,
+                                     const GURL& url,
+                                     const GURL& requestor_url,
+                                     ServiceProviderPtr service_provider) {
   if (interceptor_) {
     shell_impl->ConnectToClient(
         requestor_url,
         interceptor_->OnConnectToClient(url, service_provider.Pass()));
   } else {
     shell_impl->ConnectToClient(requestor_url, service_provider.Pass());
   }
 }
 
+void ServiceManager::RegisterLoadedApplication(
+    const GURL& url,
+    const GURL& requestor_url,
+    ServiceProviderPtr service_provider,
+    ScopedMessagePipeHandle* shell_handle) {
+  ShellImpl* shell_impl = NULL;
+  URLToShellImplMap::iterator iter = url_to_shell_impl_.find(url);
+  if (iter != url_to_shell_impl_.end()) {
+    // This can happen because services are loaded asynchronously. So if we get
+    // two requests for the same service close to each other, we might get here
+    // and find that we already have it.
+    shell_impl = iter->second;
+  } else {
+    MessagePipe pipe;
+    shell_impl = WeakBindToPipe(new ShellImpl(this, url), pipe.handle1.Pass());
+    url_to_shell_impl_[url] = shell_impl;
+    *shell_handle = pipe.handle0.Pass();
+  }
+
+  ConnectToClient(shell_impl, url, requestor_url, service_provider.Pass());
+}
+
+void ServiceManager::LoadWithContentHandler(
+    const GURL& content_url,
+    const GURL& requestor_url,
+    const GURL& content_handler_url,
+    URLResponsePtr content,
+    ServiceProviderPtr service_provider) {
+  ContentHandlerConnection* connection = NULL;
+  URLToContentHandlerMap::iterator iter =
+      url_to_content_handler_.find(content_handler_url);
+  if (iter != url_to_content_handler_.end()) {
+    connection = iter->second;
+  } else {
+    connection = new ContentHandlerConnection(this, content_handler_url);
+    url_to_content_handler_[content_handler_url] = connection;
+  }
+  connection->content_handler->OnConnect(content_url.spec(),
+                                         content.Pass(),
+                                         service_provider.Pass());
+}
+
 void ServiceManager::SetLoaderForURL(scoped_ptr<ServiceLoader> loader,
                                      const GURL& url) {
   URLToLoaderMap::iterator it = url_to_loader_.find(url);
   if (it != url_to_loader_.end())
     delete it->second;
   url_to_loader_[url] = loader.release();
 }
 
 void ServiceManager::SetLoaderForScheme(scoped_ptr<ServiceLoader> loader,
                                         const std::string& scheme) {
@@ skipping 36 matching lines @@
   StubServiceProvider* stub_sp = new StubServiceProvider;
   ServiceProviderPtr spp;
   BindToProxy(stub_sp, &spp);
   ConnectToApplication(application_url, GURL(), spp.Pass());
   MessagePipe pipe;
   stub_sp->GetRemoteServiceProvider()->ConnectToService(
       interface_name, pipe.handle1.Pass());
   return pipe.handle0.Pass();
 }
 }  // namespace mojo