Accept inbound connections on unix domain socket

mojo/shell/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/context.h"
 
 #include <vector>
 
+#include "base/bind.h"
 #include "base/command_line.h"
+#include "base/files/file_path.h"
 #include "base/lazy_instance.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/scoped_vector.h"
 #include "base/strings/string_split.h"
 #include "build/build_config.h"
 #include "gpu/command_buffer/service/mailbox_manager.h"
 #include "mojo/application_manager/application_loader.h"
 #include "mojo/application_manager/application_manager.h"
 #include "mojo/application_manager/background_shell_application_loader.h"
 #include "mojo/embedder/embedder.h"
 #include "mojo/embedder/simple_platform_support.h"
 #include "mojo/public/cpp/application/application_connection.h"
 #include "mojo/public/cpp/application/application_delegate.h"
 #include "mojo/public/cpp/application/application_impl.h"
 #include "mojo/shell/dynamic_application_loader.h"
+#include "mojo/shell/external_application_listener.h"
 #include "mojo/shell/in_process_dynamic_service_runner.h"
 #include "mojo/shell/out_of_process_dynamic_service_runner.h"
 #include "mojo/shell/switches.h"
 #include "mojo/shell/ui_application_loader_android.h"
 #include "mojo/spy/spy.h"
 
 #if defined(OS_LINUX)
 #include "mojo/shell/dbus_application_loader_linux.h"
 #endif  // defined(OS_LINUX)
 
@@ skipping 136 matching lines @@
 void Context::Init() {
   application_manager_.set_delegate(this);
   setup.Get();
   task_runners_.reset(
       new TaskRunners(base::MessageLoop::current()->message_loop_proxy()));
 
   for (size_t i = 0; i < arraysize(kLocalMojoURLs); ++i)
     mojo_url_resolver_.AddLocalFileMapping(GURL(kLocalMojoURLs[i]));
 
   base::CommandLine* command_line = base::CommandLine::ForCurrentProcess();
+
+  if (command_line->HasSwitch(switches::kEnableExternalApplications)) {
+    listener_ = ExternalApplicationListener::Create(
+        task_runners_->shell_runner(), task_runners_->io_runner());
+    listener_->ListenInBackground(
+        ExternalApplicationListener::ConstructDefaultSocketPath(),
+        base::Bind(&ApplicationManager::RegisterExternalApplication,
+                   base::Unretained(&application_manager_)));
+  }
   scoped_ptr<DynamicServiceRunnerFactory> runner_factory;
   if (command_line->HasSwitch(switches::kEnableMultiprocess))
     runner_factory.reset(new OutOfProcessDynamicServiceRunnerFactory());
   else
     runner_factory.reset(new InProcessDynamicServiceRunnerFactory());
 
   DynamicApplicationLoader* dynamic_application_loader =
       new DynamicApplicationLoader(this, runner_factory.Pass());
   InitContentHandlers(dynamic_application_loader, command_line);
   application_manager_.set_default_loader(
@@ skipping 27 matching lines @@
   {
     scoped_ptr<BackgroundShellApplicationLoader> loader(
         new BackgroundShellApplicationLoader(
             scoped_ptr<ApplicationLoader>(new NetworkApplicationLoader()),
             "network_service",
             base::MessageLoop::TYPE_IO));
     application_manager_.SetLoaderForURL(loader.PassAs<ApplicationLoader>(),
                                          GURL("mojo:mojo_network_service"));
   }
 #endif
+
+  if (listener_)
+    listener_->WaitForListening();
 }
 
 void Context::OnApplicationError(const GURL& gurl) {
   if (app_urls_.find(gurl) != app_urls_.end()) {
     app_urls_.erase(gurl);
     if (app_urls_.empty() && base::MessageLoop::current()->is_running())
       base::MessageLoop::current()->Quit();
   }
 }
 
 void Context::Run(const GURL& url) {
   EmptyServiceProvider* sp = new EmptyServiceProvider;
   ServiceProviderPtr spp;
   BindToProxy(sp, &spp);
 
   app_urls_.insert(url);
   application_manager_.ConnectToApplication(url, GURL(), spp.Pass());
 }
 
 ScopedMessagePipeHandle Context::ConnectToServiceByName(
     const GURL& application_url,
     const std::string& service_name) {
   app_urls_.insert(application_url);
   return application_manager_.ConnectToServiceByName(
       application_url, service_name).Pass();
 }
 
 }  // namespace shell
 }  // namespace mojo