7/ Eliminate on_application_end from ConnectParams

mojo/shell/standalone/context.cc

 // Copyright 2013 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/standalone/context.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <utility>
@@ skipping 72 matching lines @@
 const size_t kMaxBlockingPoolThreads = 3;
 
 scoped_ptr<base::Thread> CreateIOThread(const char* name) {
   scoped_ptr<base::Thread> thread(new base::Thread(name));
   base::Thread::Options options;
   options.message_loop_type = base::MessageLoop::TYPE_IO;
   thread->StartWithOptions(options);
   return thread;
 }
 
+void OnInstanceQuit(const GURL& url, const Identity& identity) {
+  if (url == identity.url())
+    base::MessageLoop::current()->QuitWhenIdle();
+}
+
 }  // namespace
 
 Context::Context()
     : io_thread_(CreateIOThread("io_thread")),
       main_entry_time_(base::Time::Now()) {}
 
 Context::~Context() {
   DCHECK(!base::MessageLoop::current());
   blocking_pool_->Shutdown();
 }
@@ skipping 33 matching lines @@
                << "supported because statics in apps interact. Use static build"
                << " or don't pass --single-process.";
 #endif
     runner_factory.reset(
         new InProcessNativeRunnerFactory(blocking_pool_.get()));
   } else {
     runner_factory.reset(new OutOfProcessNativeRunnerFactory(
         blocking_pool_.get(), command_line_switches_));
   }
   application_manager_.reset(new ApplicationManager(
-    std::move(runner_factory), blocking_pool_.get(), true));
+      std::move(runner_factory), blocking_pool_.get(), true));
 
   shell::mojom::InterfaceProviderPtr tracing_remote_interfaces;
   shell::mojom::InterfaceProviderPtr tracing_local_interfaces;
   new TracingInterfaceProvider(&tracer_, GetProxy(&tracing_local_interfaces));
 
   scoped_ptr<ConnectParams> params(new ConnectParams);
   params->set_source(Identity(GURL("mojo:shell"), std::string(),
                               GetPermissiveCapabilityFilter()));
   params->set_target(Identity(GURL("mojo:tracing"), std::string(),
                               GetPermissiveCapabilityFilter()));
@@ skipping 38 matching lines @@
                                          base::Bind(edk::ShutdownIPCSupport));
   // We'll quit when we get OnShutdownComplete().
   base::MessageLoop::current()->Run();
 }
 
 void Context::OnShutdownComplete() {
   DCHECK_EQ(base::MessageLoop::current()->task_runner(), shell_runner_);
   base::MessageLoop::current()->QuitWhenIdle();
 }
 
+void Context::RunCommandLineApplication() {
+  base::CommandLine* command_line = base::CommandLine::ForCurrentProcess();
+  base::CommandLine::StringVector args = command_line->GetArgs();
+  for (size_t i = 0; i < args.size(); ++i) {
+    GURL possible_app(args[i]);
+    if (possible_app.SchemeIs("mojo")) {
+      Run(possible_app);
+      break;
+    }
+  }
+}
+
 void Context::Run(const GURL& url) {
-  DCHECK(app_complete_callback_.is_null());
+  application_manager_->SetInstanceQuitCallback(
+      base::Bind(&OnInstanceQuit, url));
+
   shell::mojom::InterfaceProviderPtr remote_interfaces;
   shell::mojom::InterfaceProviderPtr local_interfaces;
 
-  app_urls_.insert(url);
-
   scoped_ptr<ConnectParams> params(new ConnectParams);
   params->set_target(
       Identity(url, std::string(), GetPermissiveCapabilityFilter()));
   params->set_remote_interfaces(GetProxy(&remote_interfaces));
   params->set_local_interfaces(std::move(local_interfaces));
-  params->set_on_application_end(
-      base::Bind(&Context::OnApplicationEnd, base::Unretained(this), url));
   application_manager_->Connect(std::move(params));
 }
 
-void Context::RunCommandLineApplication(const base::Closure& callback) {
-  DCHECK(app_urls_.empty());
-  DCHECK(app_complete_callback_.is_null());
-  base::CommandLine* command_line = base::CommandLine::ForCurrentProcess();
-  base::CommandLine::StringVector args = command_line->GetArgs();
-  for (size_t i = 0; i < args.size(); ++i) {
-    GURL possible_app(args[i]);
-    if (possible_app.SchemeIs("mojo")) {
-      Run(possible_app);
-      app_complete_callback_ = callback;
-      break;
-    }
-  }
-}
-
-void Context::OnApplicationEnd(const GURL& url) {
-  if (app_urls_.find(url) != app_urls_.end()) {
-    app_urls_.erase(url);
-    if (app_urls_.empty() && base::MessageLoop::current()->is_running()) {
-      DCHECK_EQ(base::MessageLoop::current()->task_runner(), shell_runner_);
-      if (app_complete_callback_.is_null()) {
-        base::MessageLoop::current()->QuitWhenIdle();
-      } else {
-        app_complete_callback_.Run();
-      }
-    }
-  }
-}
-
 }  // namespace shell
 }  // namespace mojo