Index application by URL and identity for multiprocess.

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 "base/bind.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/stl_util.h"
@@ skipping 67 matching lines @@
 }
 
 ApplicationManager::TestAPI::~TestAPI() {
 }
 
 bool ApplicationManager::TestAPI::HasCreatedInstance() {
   return has_created_instance;
 }
 
 bool ApplicationManager::TestAPI::HasFactoryForURL(const GURL& url) const {
-  return manager_->url_to_shell_impl_.find(url) !=
-         manager_->url_to_shell_impl_.end();
+  return manager_->identity_to_shell_impl_.find(Identity(url)) !=
+         manager_->identity_to_shell_impl_.end();
 }
 
 ApplicationManager::ApplicationManager(Delegate* delegate)
     : delegate_(delegate), weak_ptr_factory_(this) {
 }
 
 ApplicationManager::~ApplicationManager() {
   STLDeleteValues(&url_to_content_handler_);
   TerminateShellConnections();
   STLDeleteValues(&url_to_loader_);
   STLDeleteValues(&scheme_to_loader_);
 }
 
 void ApplicationManager::TerminateShellConnections() {
-  STLDeleteValues(&url_to_shell_impl_);
+  STLDeleteValues(&identity_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());
 
   // We check both the mapped and resolved urls for existing shell_impls because
@@ skipping 77 matching lines @@
                              services->Pass(), exposed_services->Pass()));
   return true;
 }
 
 InterfaceRequest<Application> ApplicationManager::RegisterShell(
     const GURL& original_url,
     const GURL& resolved_url,
     const GURL& requestor_url,
     InterfaceRequest<ServiceProvider> services,
     ServiceProviderPtr exposed_services) {
-  GURL app_url = GetBaseURLAndQuery(resolved_url, nullptr);
+  Identity app_url_and_identity(resolved_url);
 
   ApplicationPtr application;
   InterfaceRequest<Application> application_request = GetProxy(&application);
-  ShellImpl* shell =
-      new ShellImpl(application.Pass(), this, original_url, app_url);
-  url_to_shell_impl_[app_url] = shell;
+  ShellImpl* shell = new ShellImpl(application.Pass(), this, original_url,
+                                   app_url_and_identity);
+  identity_to_shell_impl_[app_url_and_identity] = shell;
   shell->InitializeApplication(GetArgsForURL(original_url));
   ConnectToClient(shell, resolved_url, requestor_url, services.Pass(),
                   exposed_services.Pass());
   return application_request.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())
+  const auto& shell_it = identity_to_shell_impl_.find(Identity(url));
+  if (shell_it != identity_to_shell_impl_.end())
     return shell_it->second;
   return nullptr;
 }
 
 void ApplicationManager::ConnectToClient(
     ShellImpl* shell_impl,
     const GURL& resolved_url,
     const GURL& requestor_url,
     InterfaceRequest<ServiceProvider> services,
     ServiceProviderPtr exposed_services) {
@@ skipping 102 matching lines @@
 
 void ApplicationManager::RegisterExternalApplication(
     const GURL& url,
     const std::vector<std::string>& args,
     ApplicationPtr application) {
   const auto& args_it = url_to_args_.find(url);
   if (args_it != url_to_args_.end()) {
     LOG(WARNING) << "--args-for provided for external application " << url
                  << " <ignored>";
   }
-  ShellImpl* shell_impl = new ShellImpl(application.Pass(), this, url, url);
-  url_to_shell_impl_[url] = shell_impl;
+  Identity url_and_identity(url);
+  ShellImpl* shell_impl =
+      new ShellImpl(application.Pass(), this, url, url_and_identity);
+  identity_to_shell_impl_[url_and_identity] = shell_impl;
   shell_impl->InitializeApplication(Array<String>::From(args));
 }
 
 void ApplicationManager::RegisterContentHandler(
     const std::string& mime_type,
     const GURL& content_handler_url) {
   DCHECK(content_handler_url.is_valid())
       << "Content handler URL is invalid for mime type " << mime_type;
   mime_type_to_url_[mime_type] = content_handler_url;
 }
@@ skipping 55 matching lines @@
   if (url_it != url_to_loader_.end())
     return url_it->second;
   auto scheme_it = scheme_to_loader_.find(url.scheme());
   if (scheme_it != scheme_to_loader_.end())
     return scheme_it->second;
   return nullptr;
 }
 
 void ApplicationManager::OnShellImplError(ShellImpl* shell_impl) {
   // Called from ~ShellImpl, so we do not need to call Destroy here.
-  const GURL url = shell_impl->url();
+  const Identity url_and_identity = shell_impl->url_and_identity();
   const GURL requested_url = shell_impl->requested_url();
   // Remove the shell.
-  URLToShellImplMap::iterator it = url_to_shell_impl_.find(url);
-  DCHECK(it != url_to_shell_impl_.end());
+  auto it = identity_to_shell_impl_.find(url_and_identity);
+  DCHECK(it != identity_to_shell_impl_.end());
   delete it->second;
-  url_to_shell_impl_.erase(it);
+  identity_to_shell_impl_.erase(it);
   delegate_->OnApplicationError(requested_url);
 }
 
 void ApplicationManager::OnContentHandlerError(
     ContentHandlerConnection* content_handler) {
   // Remove the mapping to the content handler.
   auto it =
       url_to_content_handler_.find(content_handler->content_handler_url());
   DCHECK(it != url_to_content_handler_.end());
   delete it->second;
@@ skipping 17 matching lines @@
   return Array<String>();
 }
 
 void ApplicationManager::CleanupRunner(NativeRunner* runner) {
   native_runners_.erase(
       std::find(native_runners_.begin(), native_runners_.end(), runner));
 }
 
 }  // namespace shell
 }  // namespace mojo