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(&content_handlers_);
   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;
+  ContentHandlerMap::iterator iter =
+      content_handlers_.find(content_handler_url);
+  if (iter != content_handlers_.end()) {
+    connection = iter->second;
+  } else {
+    connection = new ContentHandlerConnection(this, content_handler_url);
+    content_handlers_[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