Revert of Some more minor cleanup to ApplicationManager.

mojo/shell/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 "mojo/shell/application_manager.h"
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/logging.h"
 #include "base/macros.h"
@@ skipping 41 matching lines @@
 
 ApplicationManager::ApplicationManager(
     scoped_ptr<PackageManager> package_manager)
     : package_manager_(package_manager.Pass()),
       content_handler_id_counter_(0u),
       weak_ptr_factory_(this) {
   package_manager_->SetApplicationManager(this);
 }
 
 ApplicationManager::~ApplicationManager() {
-  IdentityToContentHandlerMap identity_to_content_handler(
-      identity_to_content_handler_);
-  for (auto& pair : identity_to_content_handler)
+  URLToContentHandlerMap url_to_content_handler(url_to_content_handler_);
+  for (auto& pair : url_to_content_handler)
     pair.second->CloseConnection();
   TerminateShellConnections();
   STLDeleteValues(&url_to_loader_);
 }
 
 void ApplicationManager::TerminateShellConnections() {
   STLDeleteValues(&identity_to_instance_);
 }
 
 void ApplicationManager::ConnectToApplication(
+    ApplicationInstance* originator,
+    URLRequestPtr app_url_request,
+    const std::string& qualifier,
+    InterfaceRequest<ServiceProvider> services,
+    ServiceProviderPtr exposed_services,
+    const CapabilityFilter& filter,
+    const base::Closure& on_application_end,
+    const Shell::ConnectToApplicationCallback& connect_callback) {
+  scoped_ptr<ConnectToApplicationParams> params(new ConnectToApplicationParams);
+  params->SetOriginatorInfo(originator);
+  params->SetURLInfo(app_url_request.Pass());
+  params->set_qualifier(qualifier);
+  params->set_services(services.Pass());
+  params->set_exposed_services(exposed_services.Pass());
+  params->set_filter(filter);
+  params->set_on_application_end(on_application_end);
+  params->set_connect_callback(connect_callback);
+
+  ConnectToApplication(params.Pass());
+}
+
+void ApplicationManager::ConnectToApplication(
     scoped_ptr<ConnectToApplicationParams> params) {
   GURL original_url = params->app_url();
   URLRequestPtr original_url_request = params->TakeAppURLRequest();
 
   TRACE_EVENT_INSTANT1("mojo_shell", "ApplicationManager::ConnectToApplication",
                        TRACE_EVENT_SCOPE_THREAD, "original_url",
                        original_url.spec());
   DCHECK(original_url.is_valid());
   DCHECK(original_url_request);
 
@@ skipping 35 matching lines @@
   return true;
 }
 
 void ApplicationManager::ConnectToApplicationWithLoader(
     scoped_ptr<ConnectToApplicationParams>* params,
     const GURL& resolved_url,
     ApplicationLoader* loader) {
   if (!(*params)->app_url().SchemeIs("mojo"))
     (*params)->SetURLInfo(resolved_url);
 
-  loader->Load(resolved_url, CreateInstance(params->Pass(), nullptr));
+  loader->Load(resolved_url, RegisterInstance(params->Pass(), nullptr));
 }
 
-InterfaceRequest<Application> ApplicationManager::CreateInstance(
+InterfaceRequest<Application> ApplicationManager::RegisterInstance(
     scoped_ptr<ConnectToApplicationParams> params,
     ApplicationInstance** resulting_instance) {
   Identity app_identity(params->app_url(), params->qualifier());
 
   ApplicationPtr application;
   InterfaceRequest<Application> application_request = GetProxy(&application);
   ApplicationInstance* instance = new ApplicationInstance(
       application.Pass(), this, params->originator_identity(), app_identity,
       params->filter(), Shell::kInvalidContentHandlerID,
       params->on_application_end());
@@ skipping 53 matching lines @@
 
   Identity originator_identity = params->originator_identity();
   CapabilityFilter originator_filter = params->originator_filter();
   CapabilityFilter filter = params->filter();
   GURL app_url = params->app_url();
   std::string qualifier = params->qualifier();
   Shell::ConnectToApplicationCallback connect_callback =
       params->connect_callback();
   params->set_connect_callback(EmptyConnectCallback());
   ApplicationInstance* app = nullptr;
-  InterfaceRequest<Application> request(CreateInstance(params.Pass(), &app));
+  InterfaceRequest<Application> request(RegisterInstance(params.Pass(), &app));
 
 
   GURL content_handler_url;
   URLResponsePtr new_response;
   if (package_manager_->HandleWithContentHandler(fetcher.get(),
                                                  app_url,
                                                  blocking_pool_,
                                                  &new_response,
                                                  &content_handler_url,
                                                  &qualifier)) {
@@ skipping 53 matching lines @@
     const Identity& originator_identity,
     const CapabilityFilter& originator_filter,
     const GURL& content_handler_url,
     const std::string& qualifier,
     const CapabilityFilter& filter,
     const Shell::ConnectToApplicationCallback& connect_callback,
     ApplicationInstance* app,
     InterfaceRequest<Application> application_request,
     URLResponsePtr url_response) {
   ContentHandlerConnection* connection = nullptr;
-  Identity content_handler_identity(content_handler_url, qualifier);
+  std::pair<GURL, std::string> key(content_handler_url, qualifier);
   // TODO(beng): Figure out the extent to which capability filter should be
   //             factored into handler identity.
-  IdentityToContentHandlerMap::iterator iter =
-      identity_to_content_handler_.find(content_handler_identity);
-  if (iter != identity_to_content_handler_.end()) {
+  URLToContentHandlerMap::iterator iter = url_to_content_handler_.find(key);
+  if (iter != url_to_content_handler_.end()) {
     connection = iter->second;
   } else {
     connection = new ContentHandlerConnection(
         this, originator_identity, originator_filter, content_handler_url,
         qualifier, filter, ++content_handler_id_counter_);
-    identity_to_content_handler_[content_handler_identity] = connection;
+    url_to_content_handler_[key] = connection;
   }
 
   app->set_requesting_content_handler_id(connection->id());
   connection->content_handler()->StartApplication(application_request.Pass(),
                                                   url_response.Pass());
   connect_callback.Run(connection->id());
 }
 
 void ApplicationManager::SetLoaderForURL(scoped_ptr<ApplicationLoader> loader,
                                          const GURL& url) {
@@ skipping 20 matching lines @@
   DCHECK(it != identity_to_instance_.end());
   delete it->second;
   identity_to_instance_.erase(it);
   if (!on_application_end.is_null())
     on_application_end.Run();
 }
 
 void ApplicationManager::OnContentHandlerConnectionClosed(
     ContentHandlerConnection* content_handler) {
   // Remove the mapping to the content handler.
-  auto it = identity_to_content_handler_.find(
-      Identity(content_handler->content_handler_url(),
-               content_handler->content_handler_qualifier()));
-  DCHECK(it != identity_to_content_handler_.end());
-  identity_to_content_handler_.erase(it);
+  auto it = url_to_content_handler_.find(
+      std::make_pair(content_handler->content_handler_url(),
+                     content_handler->content_handler_qualifier()));
+  DCHECK(it != url_to_content_handler_.end());
+  url_to_content_handler_.erase(it);
 }
 
 void ApplicationManager::CleanupRunner(NativeRunner* runner) {
   native_runners_.erase(
       std::find(native_runners_.begin(), native_runners_.end(), runner));
 }
 
+ScopedMessagePipeHandle ApplicationManager::ConnectToServiceByName(
+    const GURL& application_url,
+    const std::string& interface_name) {
+  ServiceProviderPtr services;
+  scoped_ptr<ConnectToApplicationParams> params(new ConnectToApplicationParams);
+  params->SetURLInfo(application_url);
+  params->set_services(GetProxy(&services));
+  params->set_filter(GetPermissiveCapabilityFilter());
+  ConnectToApplication(params.Pass());
+  MessagePipe pipe;
+  services->ConnectToService(interface_name, pipe.handle1.Pass());
+  return pipe.handle0.Pass();
+}
+
 Shell::ConnectToApplicationCallback EmptyConnectCallback() {
   return base::Bind(&OnEmptyOnConnectCallback);
 }
 
 }  // namespace shell
 }  // namespace mojo