Allow external applications to register for mojo: urls

shell/application_manager/application_manager.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 "shell/application_manager/application_manager.h"
 
 #include <stdio.h>
 
 #include "base/bind.h"
 #include "base/lazy_instance.h"
@@ skipping 89 matching lines @@
   STLDeleteValues(&url_to_shell_impl_);
 }
 
 void ApplicationManager::ConnectToApplication(
     const GURL& requested_url,
     const GURL& requestor_url,
     InterfaceRequest<ServiceProvider> services,
     ServiceProviderPtr exposed_services) {
   DCHECK(requested_url.is_valid());
   GURL mapped_url = delegate_->ResolveMappings(requested_url);
+
+  // We check both the mapped and resolved urls for existing shell_impls because
+  // external applications can be registered for the unresolved mojo:foo urls.
+  ShellImpl* shell_impl = GetShellImpl(mapped_url);
+  if (shell_impl) {
+    ConnectToClient(shell_impl, mapped_url, requestor_url, services.Pass(),
+                    exposed_services.Pass());
+    return;
+  }
+
+  GURL resolved_url = delegate_->ResolveURL(mapped_url);
+  shell_impl = GetShellImpl(resolved_url);
+  if (shell_impl) {
+    ConnectToClient(shell_impl, resolved_url, requestor_url, services.Pass(),
+                    exposed_services.Pass());
+    return;
+  }
+
   ApplicationLoader* loader =
       GetLoaderForURL(mapped_url, DONT_INCLUDE_DEFAULT_LOADER);
   if (loader) {
     ConnectToApplicationImpl(requested_url, mapped_url, requestor_url,
                              services.Pass(), exposed_services.Pass(), loader);
     return;
   }
 
-  GURL resolved_url = delegate_->ResolveURL(mapped_url);
   loader = GetLoaderForURL(resolved_url, INCLUDE_DEFAULT_LOADER);
   if (loader) {
     ConnectToApplicationImpl(requested_url, resolved_url, requestor_url,
                              services.Pass(), exposed_services.Pass(), loader);
     return;
   }
 
   LOG(WARNING) << "Could not find loader to load application: "
                << requested_url.spec();
 }
 
 void ApplicationManager::ConnectToApplicationImpl(
     const GURL& requested_url,
     const GURL& resolved_url,
     const GURL& requestor_url,
     InterfaceRequest<ServiceProvider> services,
     ServiceProviderPtr exposed_services,
     ApplicationLoader* loader) {
-  ShellImpl* shell = nullptr;
-  URLToShellImplMap::const_iterator shell_it =
-      url_to_shell_impl_.find(resolved_url);
-  if (shell_it != url_to_shell_impl_.end()) {
-    shell = shell_it->second;
-  } else {
-    ShellPtr shell_ptr;
-    shell =
-        new ShellImpl(GetProxy(&shell_ptr), this, requested_url, resolved_url);
-    url_to_shell_impl_[resolved_url] = shell;
-    shell->client()->Initialize(GetArgsForURL(requested_url));
+  ShellPtr shell_ptr;
+  ShellImpl* shell =
+      new ShellImpl(GetProxy(&shell_ptr), this, requested_url, resolved_url);
+  url_to_shell_impl_[resolved_url] = shell;
+  shell->client()->Initialize(GetArgsForURL(requested_url));
 
-    loader->Load(this, resolved_url, shell_ptr.Pass(),
-                 base::Bind(&ApplicationManager::LoadWithContentHandler,
-                            weak_ptr_factory_.GetWeakPtr()));
-  }
+  loader->Load(this, resolved_url, shell_ptr.Pass(),
+               base::Bind(&ApplicationManager::LoadWithContentHandler,
+                          weak_ptr_factory_.GetWeakPtr()));
   ConnectToClient(shell, resolved_url, requestor_url, services.Pass(),
                   exposed_services.Pass());
 }
 
+ShellImpl* ApplicationManager::GetShellImpl(const GURL& url) {
+  const auto& shell_it = url_to_shell_impl_.find(url);
+  if (shell_it != url_to_shell_impl_.end())
+    return shell_it->second;
+  return nullptr;
+}
+
 void ApplicationManager::ConnectToClient(
     ShellImpl* shell_impl,
     const GURL& url,
     const GURL& requestor_url,
     InterfaceRequest<ServiceProvider> services,
     ServiceProviderPtr exposed_services) {
   shell_impl->ConnectToClient(requestor_url, services.Pass(),
                               exposed_services.Pass());
 }
 
@@ skipping 95 matching lines @@
   return pipe.handle0.Pass();
 }
 
 Array<String> ApplicationManager::GetArgsForURL(const GURL& url) {
   URLToArgsMap::const_iterator args_it = url_to_args_.find(url);
   if (args_it != url_to_args_.end())
     return Array<String>::From(args_it->second);
   return Array<String>();
 }
 }  // namespace mojo