Pass Me2Me config via stdin.

remoting/host/remoting_me2me_host.cc

 // Copyright (c) 2012 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.
 //
 // This file implements a standalone host process for Me2Me.
 
 #include <string>
 
 #include "base/at_exit.h"
 #include "base/bind.h"
@@ skipping 36 matching lines @@
 #include "remoting/host/log_to_server.h"
 #include "remoting/host/network_settings.h"
 #include "remoting/host/policy_hack/policy_watcher.h"
 #include "remoting/host/session_manager_factory.h"
 #include "remoting/host/signaling_connector.h"
 #include "remoting/host/usage_stats_consent.h"
 #include "remoting/host/video_frame_capturer.h"
 #include "remoting/jingle_glue/xmpp_signal_strategy.h"
 #include "remoting/protocol/me2me_host_authenticator_factory.h"
 
+#if defined(OS_POSIX)
+#include <signal.h>

[alexeypa (please no reviews), 2012/09/05 21:41:25]

This one is needed on Mac only.

[Jamie, 2012/09/06 00:18:50]

I don't think that's true. <signal.h> is needed for SIGTERM, which we register
for on both Mac and UNIX.

+#include "remoting/host/posix/signal_handler.h"

[alexeypa (please no reviews), 2012/09/05 21:41:25]

This is used only on Linux.

[Jamie, 2012/09/06 00:18:50]

Ditto.

+#endif  // defined(OS_POSIX)
+
 #if defined(OS_MACOSX)
 #include "base/mac/scoped_cftyperef.h"
 #include "base/mac/scoped_nsautorelease_pool.h"
 #include "remoting/host/curtain_mode_mac.h"
 #endif  // defined(OS_MACOSX)
 
 #if defined(OS_POSIX)
 #include <signal.h>
 #endif  // defined(OS_POSIX)
 
@@ skipping 77 matching lines @@
     FilePath default_config_dir = remoting::GetConfigDir();
     host_config_path_ = default_config_dir.Append(kDefaultHostConfigFile);
     if (cmd_line->HasSwitch(kHostConfigSwitchName)) {
       host_config_path_ = cmd_line->GetSwitchValuePath(kHostConfigSwitchName);
     }
 #endif  // !defined(REMOTING_MULTI_PROCESS)
 
     return true;
   }
 
+#if defined(OS_POSIX)
+  void SigTermHandler(int signum) {

[alexeypa (please no reviews), 2012/09/05 21:41:25]

This will blow up, if SIGTERM is received when shutting down HostProcess.

[Jamie, 2012/09/06 00:18:50]

As of the latest revision, this will be called on the network thread, which
means that it no longer needs to post the shutdown task.

[Lambros, 2012/09/06 00:47:19]

nit: signal or signal_number ?

[Jamie, 2012/09/06 17:31:01]

Done.

+    DCHECK(signum == SIGTERM);
+    LOG(INFO) << "Caught SIGTERM: Shutting down...";
+    // base::Unretained is safe here because |this| is owned by the thread

[alexeypa (please no reviews), 2012/09/05 21:41:25]

nit: This comment is not really true. The network thread does not own
HostProcess instance, - the main thread does. Posting HostProcess::Shutdown() on
the network thread is undeed the only supported way of shutting down
HostProcess().

[Jamie, 2012/09/06 00:18:50]

This is no longer an issue with the latest revision.

+    // to which we're posting the task.
+    context_->network_task_runner()->PostTask(FROM_HERE, base::Bind(
+        &HostProcess::Shutdown, base::Unretained(this), kSuccessExitCode));
+  }
+#endif
+
   virtual void OnConfigUpdated(const std::string& serialized_config) OVERRIDE {
     DCHECK(context_->ui_task_runner()->BelongsToCurrentThread());
 
     LOG(INFO) << "Processing new host configuration.";
 
     if (!config_.SetSerializedData(serialized_config)) {
       LOG(ERROR) << "Invalid configuration.";
       OnConfigWatcherError();
       return;
     }
@@ skipping 44 matching lines @@
 
     context_->network_task_runner()->PostTask(
         FROM_HERE,
         base::Bind(&HostProcess::Shutdown, base::Unretained(this),
                    kInvalidHostConfigurationExitCode));
   }
 
   void StartWatchingConfigChanges() {
 #if !defined(REMOTING_MULTI_PROCESS)
 
 #if defined(OS_POSIX)

[alexeypa (please no reviews), 2012/09/05 21:41:25]

Shouldn't it be #if defined(OS_MAC)?

[Jamie, 2012/09/06 00:18:50]

Arguably, it isn't needed on either platform since we shouldn't be sending
SIGHUP to these processes. I don't think it's common practise to ignore signals
you're not expecting to receive.

[alexeypa (please no reviews), 2012/09/06 18:21:09]

As per our discussion: either remove this code if SIGHUP is not sent anymore or
follow up with another CL that removes SIGHUP sending code (and this code). 

[Jamie, 2012/09/06 18:32:33]

SIGHUP will never be sent to the host process by any of our code (with the
exception of the Mac launchd script, which forwards all signals so it doesn't
count). I've removed this block.

     // Ignore SIGHUP sent by the daemon controller since we use
-    // |ConfigFileWatcher| instead.
+    // |ConfigFileWatcher| on Mac and read the config from stdin on UNIX.

[alexeypa (please no reviews), 2012/09/05 21:41:25]

nit: ...on Mac and Windows...

[Jamie, 2012/09/06 00:18:50]

Done.

     signal(SIGHUP, SIG_IGN);
 #endif  // defined(OS_POSIX)
 
     // Start watching the host configuration file.
     config_watcher_.reset(new ConfigFileWatcher(context_->ui_task_runner(),
                                                 context_->file_task_runner(),
                                                 this));
     config_watcher_->Watch(host_config_path_);
 #endif  // !defined(REMOTING_MULTI_PROCESS)
   }
 
+#if defined(OS_POSIX)
+  void ListenForShutdownSignal() {
+    remoting::RegisterSignalHandler(
+        SIGTERM,
+        base::Bind(&HostProcess::SigTermHandler, base::Unretained(this)));
+  }
+#endif  // OS_POSIX
+
   void CreateAuthenticatorFactory() {
     DCHECK(context_->network_task_runner()->BelongsToCurrentThread());
     scoped_ptr<protocol::AuthenticatorFactory> factory(
         new protocol::Me2MeHostAuthenticatorFactory(
             key_pair_.GenerateCertificate(),
             *key_pair_.private_key(), host_secret_hash_));
     host_->SetAuthenticatorFactory(factory.Pass());
   }
 
   // IPC::Listener implementation.
@@ skipping 29 matching lines @@
  private:
   void ShutdownHostProcess() {
     DCHECK(context_->ui_task_runner()->BelongsToCurrentThread());
 
 #if !defined(REMOTING_MULTI_PROCESS)
     config_watcher_.reset();
 #endif  // !defined(REMOTING_MULTI_PROCESS)
 
     daemon_channel_.reset();
 
+#if defined(OS_POSIX)
+    context_->file_task_runner()->PostTask(

[alexeypa (please no reviews), 2012/09/05 21:41:25]

Why are we doing it in ShutdownHostProcess()? context_.reset() below will kill
the file thread.

Why should ListenForShutdownSignal be done on the file thread?

[Jamie, 2012/09/06 00:18:50]

Arguably, it isn't needed on either platform since we shouldn't be sending
SIGHUP to these processes. I don't think it's common practise to ignore signals
you're not expecting to receive. In any case, we shouldn't be treating Mac
differently to UNIX.

+        FROM_HERE,
+        base::Bind(&HostProcess::ListenForShutdownSignal,
+                   base::Unretained(this)));
+#endif  // OS_POSIX
+
 #if defined(OS_MACOSX) || defined(OS_WIN)
     host_user_interface_.reset();
 #endif
 
     if (policy_watcher_.get()) {
       base::WaitableEvent done_event(true, false);
       policy_watcher_->StopWatching(&done_event);
       done_event.Wait();
       policy_watcher_.reset();
     }
@@ skipping 488 matching lines @@
             user32.GetFunctionPointer("SetProcessDPIAware"));
     set_process_dpi_aware();
   }
 
   // CommandLine::Init() ignores the passed |argc| and |argv| on Windows getting
   // the command line from GetCommandLineW(), so we can safely pass NULL here.
   return main(0, NULL);
 }
 
 #endif  // defined(OS_WIN)