Cleanups in Chromoting Host.

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 19 matching lines @@
 #include "net/base/network_change_notifier.h"
 #include "net/socket/ssl_server_socket.h"
 #include "remoting/base/auto_thread_task_runner.h"
 #include "remoting/base/breakpad.h"
 #include "remoting/base/constants.h"
 #include "remoting/host/branding.h"
 #include "remoting/host/chromoting_host.h"
 #include "remoting/host/chromoting_host_context.h"
 #include "remoting/host/chromoting_messages.h"
 #include "remoting/host/config_file_watcher.h"
-#include "remoting/host/constants.h"
 #include "remoting/host/config_file_watcher.h"
 #include "remoting/host/desktop_environment_factory.h"
 #include "remoting/host/dns_blackhole_checker.h"
 #include "remoting/host/event_executor.h"
 #include "remoting/host/heartbeat_sender.h"
 #include "remoting/host/host_config.h"
 #include "remoting/host/host_event_logger.h"
+#include "remoting/host/host_exit_codes.h"
 #include "remoting/host/host_user_interface.h"
 #include "remoting/host/json_host_config.h"
 #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>
 #include "remoting/host/posix/signal_handler.h"
 #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)
-
 // N.B. OS_WIN is defined by including src/base headers.
 #if defined(OS_WIN)
 #include <commctrl.h>
 #include "remoting/host/win/session_desktop_environment_factory.h"
 #endif  // defined(OS_WIN)
 
 #if defined(TOOLKIT_GTK)
 #include "ui/gfx/gtk_util.h"
 #endif  // defined(TOOLKIT_GTK)
 
@@ skipping 102 matching lines @@
     if (!ApplyConfig()) {
       LOG(ERROR) << "Failed to apply the configuration.";
       OnConfigWatcherError();
       return;
     }
 
     // Start watching the policy (and eventually start the host) if this is
     // the first configuration update. Otherwise, post a task to create new
     // authenticator factory in case PIN has changed.
     if (policy_watcher_.get() == NULL) {
-#if defined(OS_MACOSX) || defined(OS_WIN)
       bool want_user_interface = true;
-
-#if defined(OS_MACOSX)
+#if defined(OS_LINUX)
+      want_user_interface = false;
+#elif defined(OS_MACOSX)
       // Don't try to display any UI on top of the system's login screen as this
       // is rejected by the Window Server on OS X 10.7.4, and prevents the
       // capturer from working (http://crbug.com/140984).
 
       // TODO(lambroslambrou): Use a better technique of detecting whether we're
       // running in the LoginWindow context, and refactor this into a separate
       // function to be used here and in CurtainMode::ActivateCurtain().
-      if (getuid() == 0) {
-        want_user_interface = false;
-      }
+        want_user_interface = getuid() != 0;

[Wez, 2012/09/13 23:59:34]

nit: Indentation.

[Sergey Ulanov, 2012/09/14 00:01:12]

Done.

 #endif  // OS_MACOSX
 
       if (want_user_interface) {
         host_user_interface_.reset(new HostUserInterface(context_.get()));
       }
-#endif  // OS_MACOSX || OS_WIN
 
       StartWatchingPolicy();
     } else {
       // PostTask to create new authenticator factory in case PIN has changed.
       context_->network_task_runner()->PostTask(
           FROM_HERE,
           base::Bind(&HostProcess::CreateAuthenticatorFactory,
                      base::Unretained(this)));
     }
   }
 
   virtual void OnConfigWatcherError() OVERRIDE {
     DCHECK(context_->ui_task_runner()->BelongsToCurrentThread());
 
     context_->network_task_runner()->PostTask(
         FROM_HERE,
         base::Bind(&HostProcess::Shutdown, base::Unretained(this),
                    kInvalidHostConfigurationExitCode));
   }
 
   void StartWatchingConfigChanges() {
 #if !defined(REMOTING_MULTI_PROCESS)
-
     // 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)
   }
 
+  void ListenForShutdownSignal() {
 #if defined(OS_POSIX)
-  void ListenForShutdownSignal() {
     remoting::RegisterSignalHandler(
         SIGTERM,
         base::Bind(&HostProcess::SigTermHandler, base::Unretained(this)));
+#endif  // OS_POSIX
   }
-#endif  // OS_POSIX
 
   void CreateAuthenticatorFactory() {
     DCHECK(context_->network_task_runner()->BelongsToCurrentThread());
 
     std::string local_certificate = key_pair_.GenerateCertificate();
     if (local_certificate.empty()) {
       LOG(ERROR) << "Failed to generate host certificate.";
       Shutdown(kHostInitializationFailed);
       return;
     }
@@ skipping 22 matching lines @@
   }
 
   void StartHostProcess() {
     DCHECK(context_->ui_task_runner()->BelongsToCurrentThread());
 
     if (!InitWithCommandLine(CommandLine::ForCurrentProcess())) {
       OnConfigWatcherError();
       return;
     }
 
-#if defined(OS_POSIX)
     context_->network_task_runner()->PostTask(
         FROM_HERE,
         base::Bind(&HostProcess::ListenForShutdownSignal,
                    base::Unretained(this)));
-#endif  // OS_POSIX
 
     StartWatchingConfigChanges();
   }
 
   int get_exit_code() const { return exit_code_; }
 
  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_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();
     }
 
     context_.reset();
   }
@@ skipping 238 matching lines @@
     host_->SetMaximumSessionDuration(base::TimeDelta::FromHours(20));
 #endif
 
     heartbeat_sender_.reset(new HeartbeatSender(
         this, host_id_, signal_strategy_.get(), &key_pair_));
 
     log_to_server_.reset(
         new LogToServer(host_, ServerLogEntry::ME2ME, signal_strategy_.get()));
     host_event_logger_ = HostEventLogger::Create(host_, kApplicationName);
 
-#if defined(OS_MACOSX) || defined(OS_WIN)
     if (host_user_interface_.get()) {
       host_user_interface_->Start(
           host_, base::Bind(&HostProcess::OnDisconnectRequested,
                             base::Unretained(this)));
     }
-#endif
 
     host_->Start(xmpp_login_);
 
     CreateAuthenticatorFactory();
   }
 
   void OnAuthFailed() {
     Shutdown(kInvalidOauthCredentialsExitCode);
   }
 
@@ skipping 67 matching lines @@
     heartbeat_sender_.reset();
     signaling_connector_.reset();
     signal_strategy_.reset();
   }
 
   scoped_ptr<ChromotingHostContext> context_;
   scoped_ptr<IPC::ChannelProxy> daemon_channel_;
   scoped_ptr<net::NetworkChangeNotifier> network_change_notifier_;
 
   JsonHostConfig config_;
-#if !defined(REMOTING_MULTI_PROCESS)
   FilePath host_config_path_;
   scoped_ptr<ConfigFileWatcher> config_watcher_;
-#endif  // !defined(REMOTING_MULTI_PROCESS)
 
   std::string host_id_;
   HostKeyPair key_pair_;
   protocol::SharedSecretHash host_secret_hash_;
   std::string xmpp_login_;
   std::string xmpp_auth_token_;
   std::string xmpp_auth_service_;
 
   std::string oauth_refresh_token_;
   bool oauth_use_official_client_id_;
 
   scoped_ptr<policy_hack::PolicyWatcher> policy_watcher_;
   bool allow_nat_traversal_;
   std::string talkgadget_prefix_;
 
   bool restarting_;
   bool shutting_down_;
 
   scoped_ptr<DesktopEnvironmentFactory> desktop_environment_factory_;
   scoped_ptr<XmppSignalStrategy> signal_strategy_;
   scoped_ptr<SignalingConnector> signaling_connector_;
   scoped_ptr<HeartbeatSender> heartbeat_sender_;
   scoped_ptr<LogToServer> log_to_server_;
   scoped_ptr<HostEventLogger> host_event_logger_;
 
-#if defined(OS_MACOSX) || defined(OS_WIN)
   scoped_ptr<HostUserInterface> host_user_interface_;
-#endif
 
   scoped_refptr<ChromotingHost> host_;
 
   int exit_code_;
 
 #if defined(OS_MACOSX)
     remoting::CurtainMode curtain_;
 #endif
 };
 
@@ skipping 97 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)