Neuter the wrong-way ServiceProvider (a.k.a. exposed_services).

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/command_line.h"
 #include "base/logging.h"
 #include "base/macros.h"
@@ skipping 46 matching lines @@
 }
 
 }  // namespace
 
 class ApplicationManager::ContentHandlerConnection {
  public:
   ContentHandlerConnection(ApplicationManager* manager, Identity identity)
       : manager_(manager), identity_(identity) {
     ServiceProviderPtr services;
     manager->ConnectToApplication(identity_.url, GURL(),
-                                  mojo::GetProxy(&services), nullptr,
-                                  base::Closure());
+                                  mojo::GetProxy(&services), base::Closure());
     mojo::MessagePipe pipe;
     content_handler_.Bind(
         mojo::InterfaceHandle<mojo::ContentHandler>(pipe.handle0.Pass(), 0u));
     services->ConnectToService(mojo::ContentHandler::Name_,
                                pipe.handle1.Pass());
     content_handler_.set_connection_error_handler(
         [this]() { manager_->OnContentHandlerError(this); });
   }
   ~ContentHandlerConnection() {}
 
@@ skipping 42 matching lines @@
 }
 
 void ApplicationManager::TerminateShellConnections() {
   identity_to_shell_impl_.clear();
 }
 
 void ApplicationManager::ConnectToApplication(
     const GURL& requested_url,
     const GURL& requestor_url,
     InterfaceRequest<ServiceProvider> services,
-    mojo::InterfaceHandle<ServiceProvider> exposed_services,
     const base::Closure& on_application_end) {
-  ConnectToApplicationWithParameters(
-      requested_url, requestor_url, services.Pass(), exposed_services.Pass(),
-      on_application_end, std::vector<std::string>());
+  ConnectToApplicationWithParameters(requested_url, requestor_url,
+                                     services.Pass(), on_application_end,
+                                     std::vector<std::string>());
 }
 
 void ApplicationManager::ConnectToApplicationWithParameters(
     const GURL& requested_url,
     const GURL& requestor_url,
     InterfaceRequest<ServiceProvider> services,
-    mojo::InterfaceHandle<mojo::ServiceProvider> exposed_services,
     const base::Closure& on_application_end,
     const std::vector<std::string>& pre_redirect_parameters) {
   TRACE_EVENT_INSTANT2(
       "mojo_shell", "ApplicationManager::ConnectToApplicationWithParameters",
       TRACE_EVENT_SCOPE_THREAD, "requested_url", requested_url.spec(),
       "requestor_url", requestor_url.spec());
   DCHECK(requested_url.is_valid());
 
   // We check both the mapped and resolved urls for existing shell_impls because
   // external applications can be registered for the unresolved mojo:foo urls.
 
   GURL mapped_url = delegate_->ResolveMappings(requested_url);
-  if (ConnectToRunningApplication(mapped_url, requestor_url, &services,
-                                  &exposed_services)) {
+  if (ConnectToRunningApplication(mapped_url, requestor_url, &services))
     return;
-  }
 
   GURL resolved_url = delegate_->ResolveMojoURL(mapped_url);
-  if (ConnectToRunningApplication(resolved_url, requestor_url, &services,
-                                  &exposed_services)) {
+  if (ConnectToRunningApplication(resolved_url, requestor_url, &services))
     return;
-  }
 
   // The application is not running, let's compute the parameters.
   std::vector<std::string> parameters =
       Concatenate(pre_redirect_parameters, GetArgsForURL(resolved_url));
 
   if (ConnectToApplicationWithLoader(mapped_url, requestor_url, &services,
-                                     &exposed_services, on_application_end,
-                                     parameters, GetLoaderForURL(mapped_url))) {
+                                     on_application_end, parameters,
+                                     GetLoaderForURL(mapped_url)))
     return;
-  }
-
-  if (ConnectToApplicationWithLoader(
-          resolved_url, requestor_url, &services, &exposed_services,
-          on_application_end, parameters, GetLoaderForURL(resolved_url))) {
-    return;
-  }
 
   if (ConnectToApplicationWithLoader(resolved_url, requestor_url, &services,
-                                     &exposed_services, on_application_end,
-                                     parameters, default_loader_.get())) {
+                                     on_application_end, parameters,
+                                     GetLoaderForURL(resolved_url)))
     return;
-  }
 
-  auto callback = base::Bind(
-      &ApplicationManager::HandleFetchCallback, weak_ptr_factory_.GetWeakPtr(),
-      requestor_url, base::Passed(services.Pass()),
-      base::Passed(exposed_services.Pass()), on_application_end, parameters);
+  if (ConnectToApplicationWithLoader(resolved_url, requestor_url, &services,
+                                     on_application_end, parameters,
+                                     default_loader_.get()))
+    return;
+
+  auto callback =
+      base::Bind(&ApplicationManager::HandleFetchCallback,
+                 weak_ptr_factory_.GetWeakPtr(), requestor_url,
+                 base::Passed(services.Pass()), on_application_end, parameters);
 
   if (resolved_url.SchemeIsFile()) {
     new LocalFetcher(resolved_url, GetBaseURLAndQuery(resolved_url, nullptr),
                      callback);
     return;
   }
 
   if (!url_response_disk_cache_) {
     ConnectToService(GURL("mojo:url_response_disk_cache"),
                      &url_response_disk_cache_);
@@ skipping 33 matching lines @@
   }
 
   new NetworkFetcher(options_.disable_cache, options_.force_offline_by_default,
                      resolved_url, url_response_disk_cache_.get(),
                      network_service, callback);
 }
 
 bool ApplicationManager::ConnectToRunningApplication(
     const GURL& resolved_url,
     const GURL& requestor_url,
-    InterfaceRequest<ServiceProvider>* services,
-    mojo::InterfaceHandle<mojo::ServiceProvider>* exposed_services) {
+    InterfaceRequest<ServiceProvider>* services) {
   GURL application_url = GetBaseURLAndQuery(resolved_url, nullptr);
   ShellImpl* shell_impl = GetShellImpl(application_url);
   if (!shell_impl)
     return false;
 
   DCHECK(!GetNativeApplicationOptionsForURL(application_url)
               ->new_process_per_connection);
 
-  ConnectToClient(shell_impl, resolved_url, requestor_url, services->Pass(),
-                  exposed_services->Pass());
+  ConnectToClient(shell_impl, resolved_url, requestor_url, services->Pass());
   return true;
 }
 
 bool ApplicationManager::ConnectToApplicationWithLoader(
     const GURL& resolved_url,
     const GURL& requestor_url,
     InterfaceRequest<ServiceProvider>* services,
-    mojo::InterfaceHandle<mojo::ServiceProvider>* exposed_services,
     const base::Closure& on_application_end,
     const std::vector<std::string>& parameters,
     ApplicationLoader* loader) {
   if (!loader)
     return false;
 
-  loader->Load(
-      resolved_url,
-      RegisterShell(resolved_url, requestor_url, services->Pass(),
-                    exposed_services->Pass(), on_application_end, parameters));
+  loader->Load(resolved_url,
+               RegisterShell(resolved_url, requestor_url, services->Pass(),
+                             on_application_end, parameters));
   return true;
 }
 
 Identity ApplicationManager::MakeApplicationIdentity(const GURL& resolved_url,
                                                      bool strip_query) {
   static uint64_t unique_id_number = 1;
   GURL stripped_url = GetBaseURLAndQuery(resolved_url, nullptr);
   GURL url = strip_query ? stripped_url : resolved_url;
   bool new_process_per_connection =
       GetNativeApplicationOptionsForURL(stripped_url)
           ->new_process_per_connection;
   return new_process_per_connection
              ? Identity(url, base::Uint64ToString(unique_id_number++))
              : Identity(url);
 }
 
 InterfaceRequest<Application> ApplicationManager::RegisterShell(
     const GURL& resolved_url,
     const GURL& requestor_url,
     InterfaceRequest<ServiceProvider> services,
-    mojo::InterfaceHandle<mojo::ServiceProvider> exposed_services,
     const base::Closure& on_application_end,
     const std::vector<std::string>& parameters) {
   Identity app_identity = MakeApplicationIdentity(resolved_url);
 
   mojo::ApplicationPtr application;
   InterfaceRequest<Application> application_request =
       mojo::GetProxy(&application);
   ShellImpl* shell =
       new ShellImpl(application.Pass(), this, app_identity, on_application_end);
   identity_to_shell_impl_[app_identity] = make_scoped_ptr(shell);
   shell->InitializeApplication(mojo::Array<mojo::String>::From(parameters));
-  ConnectToClient(shell, resolved_url, requestor_url, services.Pass(),
-                  exposed_services.Pass());
+  ConnectToClient(shell, resolved_url, requestor_url, services.Pass());
   return application_request;
 }
 
 // Note: If a service was created with a unique ID, intending to be unique
 // (such that multiple requests for a service result in unique processes), then
 // 'GetShellImpl' should return nullptr.
 ShellImpl* ApplicationManager::GetShellImpl(const GURL& url) {
   DCHECK(!url.has_query());
   const auto& shell_it = identity_to_shell_impl_.find(Identity(url));
   if (shell_it != identity_to_shell_impl_.end())
     return shell_it->second.get();
   return nullptr;
 }
 
 void ApplicationManager::ConnectToClient(
     ShellImpl* shell_impl,
     const GURL& resolved_url,
     const GURL& requestor_url,
-    InterfaceRequest<ServiceProvider> services,
-    mojo::InterfaceHandle<mojo::ServiceProvider> exposed_services) {
-  shell_impl->ConnectToClient(resolved_url, requestor_url, services.Pass(),
-                              exposed_services.Pass());
+    InterfaceRequest<ServiceProvider> services) {
+  shell_impl->ConnectToClient(resolved_url, requestor_url, services.Pass());
 }
 
 void ApplicationManager::HandleFetchCallback(
     const GURL& requestor_url,
     InterfaceRequest<ServiceProvider> services,
-    mojo::InterfaceHandle<mojo::ServiceProvider> exposed_services,
     const base::Closure& on_application_end,
     const std::vector<std::string>& parameters,
     scoped_ptr<Fetcher> fetcher) {
   if (!fetcher) {
     // Network error. Drop |application_request| to tell requestor.
     return;
   }
 
   GURL redirect_url = fetcher->GetRedirectURL();
   if (!redirect_url.is_empty()) {
     // And around we go again... Whee!
     ConnectToApplicationWithParameters(redirect_url, requestor_url,
-                                       services.Pass(), exposed_services.Pass(),
-                                       on_application_end, parameters);
+                                       services.Pass(), on_application_end,
+                                       parameters);
     return;
   }
 
   // We already checked if the application was running before we fetched it, but
   // it might have started while the fetch was outstanding. We don't want to
   // have two copies of the app running, so check again.
   //
   // Also, it's possible the original URL was redirected to an app that is
   // already running.
-  if (ConnectToRunningApplication(fetcher->GetURL(), requestor_url, &services,
-                                  &exposed_services)) {
+  if (ConnectToRunningApplication(fetcher->GetURL(), requestor_url, &services))
     return;
-  }
 
   InterfaceRequest<Application> request(
       RegisterShell(fetcher->GetURL(), requestor_url, services.Pass(),
-                    exposed_services.Pass(), on_application_end, parameters));
+                    on_application_end, parameters));
 
   // If the response begins with a #!mojo <content-handler-url>, use it.
   GURL content_handler_url;
   std::string shebang;
   if (fetcher->PeekContentHandler(&shebang, &content_handler_url)) {
     LoadWithContentHandler(
         content_handler_url, request.Pass(),
         fetcher->AsURLResponse(blocking_pool_,
                                static_cast<int>(shebang.size())));
     return;
@@ skipping 153 matching lines @@
   auto it = identity_to_content_handler_.find(content_handler->identity());
   DCHECK(it != identity_to_content_handler_.end());
   identity_to_content_handler_.erase(it);
 }
 
 mojo::ScopedMessagePipeHandle ApplicationManager::ConnectToServiceByName(
     const GURL& application_url,
     const std::string& interface_name) {
   ServiceProviderPtr services;
   ConnectToApplication(application_url, GURL(), mojo::GetProxy(&services),
-                       nullptr, base::Closure());
+                       base::Closure());
   mojo::MessagePipe pipe;
   services->ConnectToService(interface_name, pipe.handle1.Pass());
   return pipe.handle0.Pass();
 }
 
 std::vector<std::string> ApplicationManager::GetArgsForURL(const GURL& url) {
   GURL base_url = GetBaseURLAndQuery(url, nullptr);
   const auto& args_it = url_to_args_.find(base_url);
   if (args_it != url_to_args_.end())
     return args_it->second;
   return std::vector<std::string>();
 }
 
 void ApplicationManager::CleanupRunner(NativeRunner* runner) {
   native_runners_.erase(
       std::find(native_runners_.begin(), native_runners_.end(), runner));
 }
 
 }  // namespace shell