Revert 288013 "First cut at "content handling" support in Mojo."

trunk/src/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 <stdio.h>
+
 #include "mojo/service_manager/service_manager.h"
 
-#include <stdio.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/public/cpp/application/connect.h"
 #include "mojo/public/interfaces/application/application.mojom.h"
 #include "mojo/public/interfaces/application/shell.mojom.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::LoadCallbacksImpl : public ServiceLoader::LoadCallbacks {
- public:
-  LoadCallbacksImpl(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 ~LoadCallbacksImpl() {
-  }
-
-  // LoadCallbacks 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());
-    mojo::ConnectToService(service_provider_impl.client(), &content_handler);
-  }
-
-  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),
-      weak_ptr_factory_(this) {
+ServiceManager::ServiceManager() : interceptor_(NULL) {
 }
 
 ServiceManager::~ServiceManager() {
-  STLDeleteValues(&url_to_content_handler_);
   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()) {
-    ConnectToClient(shell_it->second, url, requestor_url,
-                    service_provider.Pass());
-    return;
+    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;
   }
-
-  scoped_refptr<LoadCallbacksImpl> callbacks(
-      new LoadCallbacksImpl(weak_ptr_factory_.GetWeakPtr(),
-                            url,
-                            requestor_url,
-                            service_provider.Pass()));
-  GetLoaderForURL(url)->Load(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