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 35 matching lines @@
 #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 "remoting/host/posix/sighup_listener.h"
+#include "remoting/host/posix/signal_handler.h"
+#include <signal.h>

[Lambros, 2012/09/05 16:35:54]

nit: move system include above project include

[Jamie, 2012/09/05 21:15:38]

Done.

 #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)
 
 // N.B. OS_WIN is defined by including src/base headers.
 #if defined(OS_WIN)
@@ skipping 87 matching lines @@
 
     host_config_path_ = default_config_dir.Append(kDefaultHostConfigFile);
     if (cmd_line->HasSwitch(kHostConfigSwitchName)) {
       host_config_path_ = cmd_line->GetSwitchValuePath(kHostConfigSwitchName);
     }
     config_.AddConfigPath(host_config_path_);
 
     return true;
   }
 
+#if defined(OS_POSIX)
+  void SignalHandler(int signum) {

[Sergey Ulanov, 2012/09/04 22:01:48]

Why not separate SighupHandler() and SigtermHandler() given that
RegisterSignalHandler() supports it?

[Jamie, 2012/09/05 21:15:38]

Done.

+    switch (signum) {
+      case SIGHUP:
+        LOG(INFO) << "Caught SIGHUP: Reloading config...";
+        ConfigUpdatedDelayed();
+        break;
+      case SIGTERM:
+        LOG(INFO) << "Caught SIGTERM: Shutting down...";
+        context_->network_task_runner()->PostTask(FROM_HERE, base::Bind(
+            &HostProcess::Shutdown, base::Unretained(this), kSuccessExitCode));

[Lambros, 2012/09/05 16:35:54]

Could you comment why base::Unretained is safe here?  Is there a possibility of
nastiness if, say, this process is sent SIGTERM immediately followed by SIGHUP? 
Or maybe we don't need to worry?

[Jamie, 2012/09/05 21:15:38]

Done.

+        break;
+      default:
+        LOG(ERROR) << "Ignoring unexpected signal " << signum;
+    }
+  }
+#endif
+
   void ConfigUpdated() {
     DCHECK(message_loop_.message_loop_proxy()->BelongsToCurrentThread());
 
     // Call ConfigUpdatedDelayed after a short delay, so that this object won't
     // try to read the updated configuration file before it has been
     // completely written.
     // If the writer moves the new configuration file into place atomically,
     // this delay may not be necessary.
     config_updated_timer_->Reset();
   }
@@ skipping 32 matching lines @@
    private:
     scoped_refptr<base::SingleThreadTaskRunner> task_runner_;
     base::Closure callback_;
 
     DISALLOW_COPY_AND_ASSIGN(ConfigChangedDelegate);
   };
 #endif  // defined(OS_WIN)
 
   void ListenForConfigChanges() {
 #if defined(OS_POSIX)
-    remoting::RegisterHupSignalHandler(
-        base::Bind(&HostProcess::ConfigUpdatedDelayed, base::Unretained(this)));
+    remoting::RegisterSignalHandler(
+        SIGHUP,
+        base::Bind(&HostProcess::SignalHandler, base::Unretained(this)));
 #elif defined(OS_WIN)
     scoped_refptr<base::files::FilePathWatcher::Delegate> delegate(
         new ConfigChangedDelegate(
             message_loop_.message_loop_proxy(),
             base::Bind(&HostProcess::ConfigUpdated, base::Unretained(this))));
     config_watcher_.reset(new base::files::FilePathWatcher());
     if (!config_watcher_->Watch(host_config_path_, delegate)) {
       LOG(ERROR) << "Couldn't watch file " << host_config_path_.value();
     }
 #endif  // defined (OS_WIN)
   }
 
+#if defined(OS_POSIX)
+  void ListenForShutdownSignal() {
+    remoting::RegisterSignalHandler(
+        SIGTERM,
+        base::Bind(&HostProcess::SignalHandler, 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 22 matching lines @@
     }
 #endif  // OS_MACOSX
 
     if (want_user_interface) {
       host_user_interface_.reset(new HostUserInterface(context_.get()));
     }
 #endif  // OS_MACOSX || OS_WIN
 
     StartWatchingPolicy();
 
-#if defined(OS_MACOSX) || defined(OS_WIN)
     context_->file_task_runner()->PostTask(
         FROM_HERE,
         base::Bind(&HostProcess::ListenForConfigChanges,
                    base::Unretained(this)));
-#endif
+
+#if defined(OS_POSIX)
+    remoting::SignalHandler handler = base::Bind(&HostProcess::SignalHandler,
+                                                 base::Unretained(this));
+    context_->file_task_runner()->PostTask(
+        FROM_HERE,
+        base::Bind(&HostProcess::ListenForShutdownSignal,
+                   base::Unretained(this)));
+#endif  // OS_POSIX
+
     message_loop_.Run();
 
 #if defined(OS_MACOSX) || defined(OS_WIN)
     host_user_interface_.reset();
 #endif
 
     daemon_channel_.reset();
     base::WaitableEvent done_event(true, false);
     policy_watcher_->StopWatching(&done_event);
     done_event.Wait();
@@ skipping 487 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)