Revert of Some more minor cleanup to ApplicationManager. (patchset #4 id:60001 of https://codereview.chromium.org/1351963002/ )

Reason for revert:
Broke Android GN.

Original issue's description:
> Some more minor cleanup to ApplicationManager.
>
> R=yzshen@chromium.org
> http://crbug.com/533085
>
> Committed: https://crrev.com/c6bde172a35b65b5a735675e840fab55921d28f8
> Cr-Commit-Position: refs/heads/master@{#349515}

TBR=yzshen@chromium.org,ben@chromium.org
NOPRESUBMIT=true
NOTREECHECKS=true
NOTRY=true

Review URL: https://codereview.chromium.org/1354043002

Cr-Commit-Position: refs/heads/master@{#349554}

14 files changed, 140 insertions, 184 deletions

diff --git a/mojo/fetcher/about_fetcher_unittest.cc b/mojo/fetcher/about_fetcher_unittest.cc
index 27c8e6a..b69d349 100644
--- a/mojo/fetcher/about_fetcher_unittest.cc
+++ b/mojo/fetcher/about_fetcher_unittest.cc
@@ -112,12 +112,10 @@ class AboutFetcherTest : public testing::Test {
 
     URLRequestPtr request(URLRequest::New());
     request->url = url;
-
-    scoped_ptr<shell::ConnectToApplicationParams> params(
-        new shell::ConnectToApplicationParams);
-    params->SetURLInfo(request.Pass());
-    params->set_services(service_provider_request.Pass());
-    application_manager_->ConnectToApplication(params.Pass());
+    application_manager_->ConnectToApplication(
+        nullptr, request.Pass(), std::string(), service_provider_request.Pass(),
+        nullptr, shell::CapabilityFilter(), base::Closure(),
+        shell::EmptyConnectCallback());
 
     run_loop.Run();
   }
diff --git a/mojo/mojo_shell.gyp b/mojo/mojo_shell.gyp
index bc0c8c5..837a7fe 100644
--- a/mojo/mojo_shell.gyp
+++ b/mojo/mojo_shell.gyp
@@ -16,8 +16,6 @@
       'shell/capability_filter.h',
       'shell/connect_to_application_params.cc',
       'shell/connect_to_application_params.h',
-      'shell/connect_util.cc',
-      'shell/connect_util.h',
       'shell/content_handler_connection.cc',
       'shell/content_handler_connection.h',
       'shell/data_pipe_peek.cc',
diff --git a/mojo/package_manager/package_manager_impl.cc b/mojo/package_manager/package_manager_impl.cc
index 8d8e19e..a2af6c1 100644
--- a/mojo/package_manager/package_manager_impl.cc
+++ b/mojo/package_manager/package_manager_impl.cc
@@ -11,7 +11,6 @@
 #include "mojo/fetcher/switches.h"
 #include "mojo/fetcher/update_fetcher.h"
 #include "mojo/shell/application_manager.h"
-#include "mojo/shell/connect_util.h"
 #include "mojo/shell/query_util.h"
 #include "mojo/shell/switches.h"
 #include "mojo/util/filename_util.h"
@@ -80,8 +79,8 @@ void PackageManagerImpl::FetchRequest(
     // LocalFetcher uses the network service to infer MIME types from URLs.
     // Skip this for mojo URLs to avoid recursively loading the network service.
     if (!network_service_ && !url.SchemeIs("mojo")) {
-      shell::ConnectToService(application_manager_,
-                              GURL("mojo:network_service"), &network_service_);
+      application_manager_->ConnectToService(GURL("mojo:network_service"),
+                                            &network_service_);
     }
     // Ownership of this object is transferred to |loader_callback|.
     // TODO(beng): this is eff'n weird.
@@ -100,8 +99,7 @@ void PackageManagerImpl::FetchRequest(
   if (url.SchemeIs("mojo") &&
       base::CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kUseUpdater)) {
-    shell::ConnectToService(application_manager_, GURL("mojo:updater"),
-                            &updater_);
+    application_manager_->ConnectToService(GURL("mojo:updater"), &updater_);
     // Ownership of this object is transferred to |loader_callback|.
     // TODO(beng): this is eff'n weird.
     new fetcher::UpdateFetcher(url, updater_.get(), loader_callback);
@@ -110,8 +108,8 @@ void PackageManagerImpl::FetchRequest(
 #endif
 
   if (!url_loader_factory_) {
-    shell::ConnectToService(application_manager_, GURL("mojo:network_service"),
-                            &url_loader_factory_);
+    application_manager_->ConnectToService(GURL("mojo:network_service"),
+                                           &url_loader_factory_);
   }
 
   // Ownership of this object is transferred to |loader_callback|.
diff --git a/mojo/runner/context.cc b/mojo/runner/context.cc
index 048de9b..b6d78e3 100644
--- a/mojo/runner/context.cc
+++ b/mojo/runner/context.cc
@@ -209,14 +209,11 @@ bool Context::Init() {
   new TracingServiceProvider(GetProxy(&tracing_service_provider_ptr));
   mojo::URLRequestPtr request(mojo::URLRequest::New());
   request->url = mojo::String::From("mojo:tracing");
-
-  scoped_ptr<shell::ConnectToApplicationParams> params(
-      new shell::ConnectToApplicationParams);
-  params->SetURLInfo(request.Pass());
-  params->set_services(GetProxy(&service_provider_ptr));
-  params->set_exposed_services(tracing_service_provider_ptr.Pass());
-  params->set_filter(shell::GetPermissiveCapabilityFilter());
-  application_manager_->ConnectToApplication(params.Pass());
+  application_manager_->ConnectToApplication(
+      nullptr, request.Pass(), std::string(), GetProxy(&service_provider_ptr),
+      tracing_service_provider_ptr.Pass(),
+      shell::GetPermissiveCapabilityFilter(), base::Closure(),
+      shell::EmptyConnectCallback());
 
   // Record the shell startup metrics used for performance testing.
   if (base::CommandLine::ForCurrentProcess()->HasSwitch(
@@ -266,16 +263,11 @@ void Context::Run(const GURL& url) {
   app_urls_.insert(url);
   mojo::URLRequestPtr request(mojo::URLRequest::New());
   request->url = mojo::String::From(url.spec());
-
-  scoped_ptr<shell::ConnectToApplicationParams> params(
-      new shell::ConnectToApplicationParams);
-  params->SetURLInfo(request.Pass());
-  params->set_services(GetProxy(&services));
-  params->set_exposed_services(exposed_services.Pass());
-  params->set_filter(shell::GetPermissiveCapabilityFilter());
-  params->set_on_application_end(
-      base::Bind(&Context::OnApplicationEnd, base::Unretained(this), url));
-  application_manager_->ConnectToApplication(params.Pass());
+  application_manager_->ConnectToApplication(
+      nullptr, request.Pass(), std::string(), GetProxy(&services),
+      exposed_services.Pass(), shell::GetPermissiveCapabilityFilter(),
+      base::Bind(&Context::OnApplicationEnd, base::Unretained(this), url),
+      shell::EmptyConnectCallback());
 }
 
 void Context::RunCommandLineApplication(const base::Closure& callback) {
diff --git a/mojo/runner/native_runner_unittest.cc b/mojo/runner/native_runner_unittest.cc
index e4a636d..bfb77b8 100644
--- a/mojo/runner/native_runner_unittest.cc
+++ b/mojo/runner/native_runner_unittest.cc
@@ -94,14 +94,10 @@ TEST_F(NativeApplicationLoaderTest, DoesNotExist) {
   ServiceProviderPtr service_provider;
   mojo::URLRequestPtr request(mojo::URLRequest::New());
   request->url = mojo::String::From(url.spec());
-
-  scoped_ptr<shell::ConnectToApplicationParams> params(
-      new shell::ConnectToApplicationParams);
-  params->SetURLInfo(request.Pass());
-  params->set_services(services.Pass());
-  params->set_exposed_services(service_provider.Pass());
-  params->set_filter(shell::GetPermissiveCapabilityFilter());
-  context_->application_manager()->ConnectToApplication(params.Pass());
+  context_->application_manager()->ConnectToApplication(
+      nullptr, request.Pass(), std::string(), services.Pass(),
+      service_provider.Pass(), shell::GetPermissiveCapabilityFilter(),
+      base::Closure(), shell::EmptyConnectCallback());
   EXPECT_FALSE(state_.runner_was_created);
   EXPECT_FALSE(state_.runner_was_started);
   EXPECT_FALSE(state_.runner_was_destroyed);
diff --git a/mojo/runner/shell_test_base.cc b/mojo/runner/shell_test_base.cc
index 517a691..8731720 100644
--- a/mojo/runner/shell_test_base.cc
+++ b/mojo/runner/shell_test_base.cc
@@ -49,14 +49,10 @@ ScopedMessagePipeHandle ShellTestBase::ConnectToService(
   ServiceProviderPtr services;
   mojo::URLRequestPtr request(mojo::URLRequest::New());
   request->url = mojo::String::From(application_url.spec());
-
-  scoped_ptr<shell::ConnectToApplicationParams> params(
-      new shell::ConnectToApplicationParams);
-  params->SetURLInfo(request.Pass());
-  params->set_services(GetProxy(&services));
-  params->set_filter(shell::GetPermissiveCapabilityFilter());
-  params->set_on_application_end(base::Bind(&QuitIfRunning));
-  shell_context_.application_manager()->ConnectToApplication(params.Pass());
+  shell_context_.application_manager()->ConnectToApplication(
+      nullptr, request.Pass(), std::string(), GetProxy(&services), nullptr,
+      shell::GetPermissiveCapabilityFilter(), base::Bind(&QuitIfRunning),
+      shell::EmptyConnectCallback());
   MessagePipe pipe;
   services->ConnectToService(service_name, pipe.handle1.Pass());
   return pipe.handle0.Pass();
diff --git a/mojo/shell/BUILD.gn b/mojo/shell/BUILD.gn
index 0d57c43..38fca1e 100644
--- a/mojo/shell/BUILD.gn
+++ b/mojo/shell/BUILD.gn
@@ -17,8 +17,6 @@ source_set("shell") {
     "capability_filter.h",
     "connect_to_application_params.cc",
     "connect_to_application_params.h",
-    "connect_util.cc",
-    "connect_util.h",
     "content_handler_connection.cc",
     "content_handler_connection.h",
     "data_pipe_peek.cc",
diff --git a/mojo/shell/application_instance.cc b/mojo/shell/application_instance.cc
index 643cfa2..18aa4e0 100644
--- a/mojo/shell/application_instance.cc
+++ b/mojo/shell/application_instance.cc
@@ -94,16 +94,9 @@ void ApplicationInstance::ConnectToApplication(
     CapabilityFilter capability_filter = GetPermissiveCapabilityFilter();
     if (!filter.is_null())
       capability_filter = filter->filter.To<CapabilityFilter>();
-
-    scoped_ptr<ConnectToApplicationParams> params(
-        new ConnectToApplicationParams);
-    params->SetOriginatorInfo(this);
-    params->SetURLInfo(app_request.Pass());
-    params->set_services(services.Pass());
-    params->set_exposed_services(exposed_services.Pass());
-    params->set_filter(capability_filter);
-    params->set_connect_callback(callback);
-    manager_->ConnectToApplication(params.Pass());
+    manager_->ConnectToApplication(
+        this, app_request.Pass(), std::string(), services.Pass(),
+        exposed_services.Pass(), capability_filter, base::Closure(), callback);
   } else {
     LOG(WARNING) << "CapabilityFilter prevented connection from: " <<
         identity_.url << " to: " << url.spec();
diff --git a/mojo/shell/application_manager.cc b/mojo/shell/application_manager.cc
index 715e6e7..d520304 100644
--- a/mojo/shell/application_manager.cc
+++ b/mojo/shell/application_manager.cc
@@ -59,9 +59,8 @@ ApplicationManager::ApplicationManager(
 }
 
 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_);
@@ -72,6 +71,28 @@ void ApplicationManager::TerminateShellConnections() {
 }
 
 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();
@@ -127,10 +148,10 @@ void ApplicationManager::ConnectToApplicationWithLoader(
   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());
@@ -204,7 +225,7 @@ void ApplicationManager::HandleFetchCallback(
       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;
@@ -278,18 +299,17 @@ void ApplicationManager::LoadWithContentHandler(
     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());
@@ -330,11 +350,11 @@ void ApplicationManager::OnApplicationInstanceError(
 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) {
@@ -342,6 +362,20 @@ void ApplicationManager::CleanupRunner(NativeRunner* runner) {
       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);
 }
diff --git a/mojo/shell/application_manager.h b/mojo/shell/application_manager.h
index 25b23a55..0ec2a6e 100644
--- a/mojo/shell/application_manager.h
+++ b/mojo/shell/application_manager.h
@@ -16,6 +16,7 @@
 #include "mojo/application/public/interfaces/shell.mojom.h"
 #include "mojo/public/cpp/bindings/interface_ptr_info.h"
 #include "mojo/public/cpp/bindings/interface_request.h"
+#include "mojo/services/updater/updater.mojom.h"
 #include "mojo/shell/application_loader.h"
 #include "mojo/shell/capability_filter.h"
 #include "mojo/shell/connect_to_application_params.h"
@@ -58,10 +59,33 @@ class ApplicationManager {
   ~ApplicationManager();
 
   // Loads a service if necessary and establishes a new client connection.
+  // |originator| can be NULL (e.g. for the first application or in tests), but
+  // typically is non-NULL and identifies the instance initiating the
+  // connection.
   // Please see the comments in connect_to_application_params.h for more details
   // about the parameters.
+  void 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);
+
   void ConnectToApplication(scoped_ptr<ConnectToApplicationParams> params);
 
+  // Must only be used by shell internals and test code as it does not forward
+  // capability filters.
+  template <typename Interface>
+  inline void ConnectToService(const GURL& application_url,
+                               InterfacePtr<Interface>* ptr) {
+    ScopedMessagePipeHandle service_handle =
+        ConnectToServiceByName(application_url, Interface::Name_);
+    ptr->Bind(InterfacePtrInfo<Interface>(service_handle.Pass(), 0u));
+  }
+
   // Sets the default Loader to be used if not overridden by SetLoaderForURL().
   void set_default_loader(scoped_ptr<ApplicationLoader> loader) {
     default_loader_ = loader.Pass();
@@ -91,9 +115,10 @@ class ApplicationManager {
   ApplicationInstance* GetApplicationInstance(const Identity& identity) const;
 
  private:
-  using IdentityToInstanceMap = std::map<Identity, ApplicationInstance*>;
-  using IdentityToContentHandlerMap =
-      std::map<Identity, ContentHandlerConnection*>;
+  using IdentityToApplicationInstanceMap =
+      std::map<Identity, ApplicationInstance*>;
+  using URLToContentHandlerMap =
+      std::map<std::pair<GURL, std::string>, ContentHandlerConnection*>;
   using URLToLoaderMap = std::map<GURL, ApplicationLoader*>;
 
   // Takes the contents of |params| only when it returns true.
@@ -108,9 +133,9 @@ class ApplicationManager {
       const GURL& resolved_url,
       ApplicationLoader* loader);
 
-  InterfaceRequest<Application> CreateInstance(
+  InterfaceRequest<Application> RegisterInstance(
       scoped_ptr<ConnectToApplicationParams> params,
-      ApplicationInstance** instance);
+      ApplicationInstance** resulting_instance);
 
   // Called once |fetcher| has found app. |params->app_url()| is the url of
   // the requested application before any mappings/resolution have been applied.
@@ -141,6 +166,10 @@ class ApplicationManager {
 
   void CleanupRunner(NativeRunner* runner);
 
+  ScopedMessagePipeHandle ConnectToServiceByName(
+      const GURL& application_url,
+      const std::string& interface_name);
+
   scoped_ptr<PackageManager> const package_manager_;
   // Loader management.
   // Loaders are chosen in the order they are listed here.
@@ -148,10 +177,11 @@ class ApplicationManager {
   scoped_ptr<ApplicationLoader> default_loader_;
   scoped_ptr<NativeRunnerFactory> native_runner_factory_;
 
-  IdentityToInstanceMap identity_to_instance_;
-  IdentityToContentHandlerMap identity_to_content_handler_;
+  IdentityToApplicationInstanceMap identity_to_instance_;
+  URLToContentHandlerMap url_to_content_handler_;
 
   base::SequencedWorkerPool* blocking_pool_;
+  updater::UpdaterPtr updater_;
   ScopedVector<NativeRunner> native_runners_;
   // Counter used to assign ids to content_handlers.
   uint32_t content_handler_id_counter_;
diff --git a/mojo/shell/application_manager_unittest.cc b/mojo/shell/application_manager_unittest.cc
index c626b01..77a959c 100644
--- a/mojo/shell/application_manager_unittest.cc
+++ b/mojo/shell/application_manager_unittest.cc
@@ -17,7 +17,6 @@
 #include "mojo/public/cpp/bindings/strong_binding.h"
 #include "mojo/shell/application_loader.h"
 #include "mojo/shell/application_manager.h"
-#include "mojo/shell/connect_util.h"
 #include "mojo/shell/fetcher.h"
 #include "mojo/shell/test.mojom.h"
 #include "mojo/shell/test_package_manager.h"
@@ -513,8 +512,8 @@ class ApplicationManagerTest : public testing::Test {
         scoped_ptr<ApplicationLoader>(test_loader_));
 
     TestServicePtr service_proxy;
-    ConnectToService(application_manager_.get(), GURL(kTestURLString),
-                     &service_proxy);
+    application_manager_->ConnectToService(GURL(kTestURLString),
+                                           &service_proxy);
     test_client_.reset(new TestClient(service_proxy.Pass()));
   }
 
@@ -590,14 +589,12 @@ TEST_F(ApplicationManagerTest, SetLoaders) {
 
   // test::test1 should go to url_loader.
   TestServicePtr test_service;
-  ConnectToService(application_manager_.get(), GURL("test:test1"),
-                   &test_service);
+  application_manager_->ConnectToService(GURL("test:test1"), &test_service);
   EXPECT_EQ(1, url_loader->num_loads());
   EXPECT_EQ(0, default_loader->num_loads());
 
   // http::test1 should go to default loader.
-  ConnectToService(application_manager_.get(), GURL("http:test1"),
-                   &test_service);
+  application_manager_->ConnectToService(GURL("http:test1"), &test_service);
   EXPECT_EQ(1, url_loader->num_loads());
   EXPECT_EQ(1, default_loader->num_loads());
 }
@@ -612,7 +609,7 @@ TEST_F(ApplicationManagerTest, ACallB) {
   AddLoaderForURL(GURL(kTestBURLString), kTestAURLString);
 
   TestAPtr a;
-  ConnectToService(application_manager_.get(), GURL(kTestAURLString), &a);
+  application_manager_->ConnectToService(GURL(kTestAURLString), &a);
   a->CallB();
   loop_.Run();
   EXPECT_EQ(1, tester_context_.num_b_calls());
@@ -628,7 +625,7 @@ TEST_F(ApplicationManagerTest, BCallC) {
   AddLoaderForURL(GURL(kTestBURLString), kTestAURLString);
 
   TestAPtr a;
-  ConnectToService(application_manager_.get(), GURL(kTestAURLString), &a);
+  application_manager_->ConnectToService(GURL(kTestAURLString), &a);
   a->CallCFromB();
   loop_.Run();
 
@@ -644,7 +641,7 @@ TEST_F(ApplicationManagerTest, BDeleted) {
   AddLoaderForURL(GURL(kTestBURLString), std::string());
 
   TestAPtr a;
-  ConnectToService(application_manager_.get(), GURL(kTestAURLString), &a);
+  application_manager_->ConnectToService(GURL(kTestAURLString), &a);
 
   a->CallB();
   loop_.Run();
@@ -667,7 +664,7 @@ TEST_F(ApplicationManagerTest, ANoLoadB) {
   AddLoaderForURL(GURL(kTestBURLString), "test:TestC");
 
   TestAPtr a;
-  ConnectToService(application_manager_.get(), GURL(kTestAURLString), &a);
+  application_manager_->ConnectToService(GURL(kTestAURLString), &a);
   a->CallB();
   loop_.Run();
   EXPECT_EQ(0, tester_context_.num_b_calls());
@@ -682,7 +679,7 @@ TEST_F(ApplicationManagerTest, NoServiceNoLoad) {
   // There is no TestC service implementation registered with
   // ApplicationManager, so this cannot succeed (but also shouldn't crash).
   TestCPtr c;
-  ConnectToService(application_manager_.get(), GURL(kTestAURLString), &c);
+  application_manager_->ConnectToService(GURL(kTestAURLString), &c);
   c.set_connection_error_handler(
       []() { base::MessageLoop::current()->QuitWhenIdle(); });
 
@@ -745,29 +742,29 @@ TEST_F(ApplicationManagerTest, SameIdentityShouldNotCauseDuplicateLoad) {
   EXPECT_EQ(1, test_loader_->num_loads());
 
   TestServicePtr test_service;
-  ConnectToService(application_manager_.get(),
-                   GURL("http://www.example.org/abc?def"), &test_service);
+  application_manager_->ConnectToService(GURL("http://www.example.org/abc?def"),
+                                         &test_service);
   EXPECT_EQ(2, test_loader_->num_loads());
 
   // Exactly the same URL as above.
-  ConnectToService(application_manager_.get(),
-                   GURL("http://www.example.org/abc?def"), &test_service);
+  application_manager_->ConnectToService(GURL("http://www.example.org/abc?def"),
+                                         &test_service);
   EXPECT_EQ(2, test_loader_->num_loads());
 
   // The same identity as the one above because only the query string is
   // different.
-  ConnectToService(application_manager_.get(),
-                   GURL("http://www.example.org/abc"), &test_service);
+  application_manager_->ConnectToService(GURL("http://www.example.org/abc"),
+                                         &test_service);
   EXPECT_EQ(2, test_loader_->num_loads());
 
   // A different identity because the path is different.
-  ConnectToService(application_manager_.get(),
-                   GURL("http://www.example.org/another_path"), &test_service);
+  application_manager_->ConnectToService(
+      GURL("http://www.example.org/another_path"), &test_service);
   EXPECT_EQ(3, test_loader_->num_loads());
 
   // A different identity because the domain is different.
-  ConnectToService(application_manager_.get(),
-                   GURL("http://www.another_domain.org/abc"), &test_service);
+  application_manager_->ConnectToService(
+      GURL("http://www.another_domain.org/abc"), &test_service);
   EXPECT_EQ(4, test_loader_->num_loads());
 }
 
diff --git a/mojo/shell/capability_filter_unittest.cc b/mojo/shell/capability_filter_unittest.cc
index 1dbc35b..0c33a8f 100644
--- a/mojo/shell/capability_filter_unittest.cc
+++ b/mojo/shell/capability_filter_unittest.cc
@@ -343,15 +343,10 @@ class CapabilityFilterTest : public testing::Test {
         AddService<Validator>(validator_);
     URLRequestPtr request(URLRequest::New());
     request->url = String::From(url);
-
-    scoped_ptr<ConnectToApplicationParams> params(
-        new ConnectToApplicationParams);
-    params->SetURLInfo(request.Pass());
-    params->set_services(GetProxy(&services));
-    params->set_exposed_services(exposed_services.Pass());
-    params->set_filter(filter);
-    params->set_on_application_end(base::MessageLoop::QuitWhenIdleClosure());
-    application_manager_->ConnectToApplication(params.Pass());
+    application_manager_->ConnectToApplication(
+        nullptr, request.Pass(), std::string(), GetProxy(&services),
+        exposed_services.Pass(), filter,
+        base::MessageLoop::QuitWhenIdleClosure(), EmptyConnectCallback());
   }
 
   void InitValidator(const std::set<std::string>& expectations) {
diff --git a/mojo/shell/connect_util.cc b/mojo/shell/connect_util.cc
deleted file mode 100644
index 0bffc5a4..0000000
--- a/mojo/shell/connect_util.cc
+++ /dev/null
@@ -1,30 +0,0 @@
-// Copyright 2015 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/connect_util.h"
-
-#include "mojo/shell/application_manager.h"
-#include "mojo/shell/capability_filter.h"
-#include "mojo/shell/connect_to_application_params.h"
-
-namespace mojo {
-namespace shell {
-
-ScopedMessagePipeHandle ConnectToServiceByName(
-    ApplicationManager* application_manager,
-    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());
-  application_manager->ConnectToApplication(params.Pass());
-  MessagePipe pipe;
-  services->ConnectToService(interface_name, pipe.handle1.Pass());
-  return pipe.handle0.Pass();
-}
-
-}  // namespace shell
-}  // namespace mojo
diff --git a/mojo/shell/connect_util.h b/mojo/shell/connect_util.h
deleted file mode 100644
index 780f7a9..0000000
--- a/mojo/shell/connect_util.h
+++ /dev/null
@@ -1,39 +0,0 @@
-// Copyright 2015 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.
-
-#ifndef MOJO_SHELL_CONNECT_UTIL_H_
-#define MOJO_SHELL_CONNECT_UTIL_H_
-
-#include "third_party/mojo/src/mojo/public/cpp/bindings/interface_ptr.h"
-#include "third_party/mojo/src/mojo/public/cpp/system/handle.h"
-
-class GURL;
-
-namespace mojo {
-namespace shell {
-
-class ApplicationManager;
-
-ScopedMessagePipeHandle ConnectToServiceByName(
-    ApplicationManager* application_manager,
-    const GURL& application_url,
-    const std::string& interface_name);
-
-// Must only be used by shell internals and test code as it does not forward
-// capability filters.
-template <typename Interface>
-inline void ConnectToService(ApplicationManager* application_manager,
-                             const GURL& application_url,
-                             InterfacePtr<Interface>* ptr) {
-  ScopedMessagePipeHandle service_handle =
-      ConnectToServiceByName(application_manager, application_url,
-                             Interface::Name_);
-  ptr->Bind(InterfacePtrInfo<Interface>(service_handle.Pass(), 0u));
-}
-
-}  // namespace shell
-}  // namespace mojo
-
-
-#endif  // MOJO_SHELL_CONNECT_UTIL_H_