7/ Eliminate on_application_end from ConnectParams

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 <stdint.h>
 
 #include <utility>
 
@@ skipping 74 matching lines @@
   InitPackageManager(register_mojo_url_schemes);
 }
 
 ApplicationManager::~ApplicationManager() {
   TerminateShellConnections();
   STLDeleteValues(&url_to_loader_);
   for (auto& runner : native_runners_)
     runner.reset();
 }
 
+void ApplicationManager::SetInstanceQuitCallback(
+    base::Callback<void(const Identity&)> callback) {
+  instance_quit_callback_ = callback;
+}
+
 void ApplicationManager::Connect(scoped_ptr<ConnectParams> params) {
   TRACE_EVENT_INSTANT1("mojo_shell", "ApplicationManager::Connect",
                        TRACE_EVENT_SCOPE_THREAD, "original_url",
                        params->target().url().spec());
   DCHECK(params->target().url().is_valid());
 
   // Connect to an existing matching instance, if possible.
   if (ConnectToExistingInstance(&params))
     return;
 
@@ skipping 11 matching lines @@
     delete it->second;
   url_to_loader_[url] = loader.release();
 }
 
 void ApplicationManager::TerminateShellConnections() {
   STLDeleteValues(&identity_to_instance_);
 }
 
 void ApplicationManager::OnApplicationInstanceError(
     ApplicationInstance* instance) {
-  // Called from ~ApplicationInstance, so we do not need to call Destroy here.
   const Identity identity = instance->identity();
-  base::Closure on_application_end = instance->on_application_end();
   // Remove the shell.
   auto it = identity_to_instance_.find(identity);
   DCHECK(it != identity_to_instance_.end());
   int id = instance->id();
   delete it->second;
   identity_to_instance_.erase(it);
   listeners_.ForAllPtrs(
       [this, id](mojom::ApplicationManagerListener* listener) {
         listener->ApplicationInstanceDestroyed(id);
       });
-  if (!on_application_end.is_null())
-    on_application_end.Run();
+  if (!instance_quit_callback_.is_null())
+    instance_quit_callback_.Run(identity);
 }
 
 ApplicationInstance* ApplicationManager::GetApplicationInstance(
   const Identity& identity) const {
   const auto& it = identity_to_instance_.find(identity);
   return it != identity_to_instance_.end() ? it->second : nullptr;
 }
 
 void ApplicationManager::ApplicationPIDAvailable(
     uint32_t id,
@@ skipping 36 matching lines @@
     mojom::CapabilityFilterPtr filter,
     mojom::PIDReceiverRequest pid_receiver) {
   // We don't call ConnectToClient() here since the instance was created
   // manually by other code, not in response to a Connect() request. The newly
   // created instance is identified by |url| and may be subsequently reached by
   // client code using this identity.
   CapabilityFilter local_filter = filter->filter.To<CapabilityFilter>();
   Identity target_id(url.To<GURL>(), std::string(), local_filter);
   mojom::ShellClientRequest request;
   // TODO(beng): do better than url.spec() for application name.
-  ApplicationInstance* instance =
-      CreateInstance(target_id, base::Closure(), url, &request);
+  ApplicationInstance* instance = CreateInstance(target_id, url, &request);
   instance->BindPIDReceiver(std::move(pid_receiver));
   scoped_ptr<NativeRunner> runner =
       native_runner_factory_->Create(base::FilePath());
   runner->InitHost(std::move(channel), std::move(request));
   instance->SetNativeRunner(runner.get());
   native_runners_.push_back(std::move(runner));
 }
 
 void ApplicationManager::AddListener(
     mojom::ApplicationManagerListenerPtr listener) {
   Array<mojom::ApplicationInfoPtr> applications;
   for (auto& entry : identity_to_instance_)
     applications.push_back(CreateApplicationInfoForInstance(entry.second));
   listener->SetRunningApplications(std::move(applications));
 
   listeners_.AddInterfacePtr(std::move(listener));
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // ApplicationManager, private:
 
 void ApplicationManager::InitPackageManager(bool register_mojo_url_schemes) {
   scoped_ptr<ApplicationLoader> loader(
       new package_manager::Loader(task_runner_, register_mojo_url_schemes));
 
   mojom::ShellClientRequest request;
   GURL url("mojo://package_manager/");
-  CreateInstance(Identity(url), base::Closure(), url.spec(), &request);
+  CreateInstance(Identity(url), url.spec(), &request);
   loader->Load(url, std::move(request));
 
   SetLoaderForURL(std::move(loader), url);
 
   ConnectToInterface(this, CreateShellIdentity(), url, &shell_resolver_);
 }
 
 bool ApplicationManager::ConnectToExistingInstance(
     scoped_ptr<ConnectParams>* params) {
   ApplicationInstance* instance = GetApplicationInstance((*params)->target());
   if (!instance)
     return false;
   instance->ConnectToClient(std::move(*params));
   return true;
 }
 
 ApplicationInstance* ApplicationManager::CreateInstance(
     const Identity& target_id,
-    const base::Closure& on_application_end,
     const String& application_name,
     mojom::ShellClientRequest* request) {
   mojom::ShellClientPtr shell_client;
   *request = GetProxy(&shell_client);
   ApplicationInstance* instance = new ApplicationInstance(
-      std::move(shell_client), this, target_id, on_application_end,
-      application_name);
+      std::move(shell_client), this, target_id, application_name);
   DCHECK(identity_to_instance_.find(target_id) ==
          identity_to_instance_.end());
   identity_to_instance_[target_id] = instance;
   mojom::ApplicationInfoPtr application_info =
       CreateApplicationInfoForInstance(instance);
   listeners_.ForAllPtrs(
       [this, &application_info](mojom::ApplicationManagerListener* listener) {
         listener->ApplicationInstanceCreated(application_info.Clone());
       });
   instance->InitializeApplication();
@@ skipping 45 matching lines @@
     const String& application_name,
     mojom::CapabilityFilterPtr base_filter) {
   // It's possible that when this manifest request was issued, another one was
   // already in-progress and completed by the time this one did, and so the
   // requested application may already be running.
   if (ConnectToExistingInstance(&params))
     return;
 
   Identity source = params->source(), target = params->target();
   mojom::ShellClientRequest request;
-  ApplicationInstance* instance = CreateInstance(
-      params->target(), params->on_application_end(), application_name,
-      &request);
+  ApplicationInstance* instance =
+      CreateInstance(params->target(), application_name, &request);
   instance->ConnectToClient(std::move(params));
 
   if (LoadWithLoader(target, &request))
     return;
 
   CHECK(!file_url.is_null() && !application_name.is_null() &&
         !base_filter.is_null());
 
   GURL resolved_gurl = resolved_url.To<GURL>();
   if (target.url().spec() != resolved_url) {
@@ skipping 53 matching lines @@
   info->name = instance->application_name();
   if (instance->identity().url().spec() == "mojo://shell/")
     info->pid = base::Process::Current().Pid();
   else
     info->pid = instance->pid();
   return info;
 }
 
 }  // namespace shell
 }  // namespace mojo