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 71 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();

[sky, 2016/02/19 05:20:51]

Ick, quitting arbitrary messageloop is error prone. But the old code was doing
this too. 

The old code would only quit once all the urls started complete. AFAICT you quit
once the last url completes.

+}
+
 }  // namespace
 
 Context::Context()
     : main_entry_time_(base::Time::Now()),
       io_thread_(CreateIOThread("io_thread")) {}
 
 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()));
   }
   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(

[sky, 2016/02/19 05:20:51]

If Run() is called multiple-times doesn't the new call to
SetInstanceQuitCallback clobber the old value (there is only one callback).

+      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