Add status service for remoting 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 30 matching lines @@
 #include "remoting/host/curtaining_host_observer.h"
 #include "remoting/host/desktop_environment_factory.h"
 #include "remoting/host/desktop_resizer.h"
 #include "remoting/host/desktop_session_connector.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_status_service.h"
 #include "remoting/host/host_user_interface.h"
 #include "remoting/host/ipc_consts.h"
 #include "remoting/host/ipc_desktop_environment_factory.h"
 #include "remoting/host/json_host_config.h"
 #include "remoting/host/logging.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/resizing_host_observer.h"
 #include "remoting/host/session_manager_factory.h"
@@ skipping 36 matching lines @@
 // This is used for tagging system event logs.
 const char kApplicationName[] = "chromoting";
 
 // The command line switch used to get version of the daemon.
 const char kVersionSwitchName[] = "version";
 
 // The command line switch used to pass name of the pipe to capture audio on
 // linux.
 const char kAudioPipeSwitchName[] = "audio-pipe-name";
 
+// The command line switch used to enable host status service.
+const char kEnableStatusServiceSwitchName[] = "enable-status-service";
+
 void QuitMessageLoop(MessageLoop* message_loop) {
   message_loop->PostTask(FROM_HERE, MessageLoop::QuitClosure());
 }
 
 // Returns true if GetUsername() is implemented on this platform.
 bool CanGetUsername() {
 #if defined(OS_LINUX)
   return true;
 #else  // defined(OS_LINUX)
   return false;
@@ skipping 69 matching lines @@
   // Applies the host config, returning true if successful.
   bool ApplyConfig(scoped_ptr<JsonHostConfig> config);
 
   void OnPolicyUpdate(scoped_ptr<base::DictionaryValue> policies);
   bool OnHostDomainPolicyUpdate(const std::string& host_domain);
   bool OnUsernamePolicyUpdate(bool username_match_required);
   bool OnNatPolicyUpdate(bool nat_traversal_enabled);
   bool OnCurtainPolicyUpdate(bool curtain_required);
   bool OnHostTalkGadgetPrefixPolicyUpdate(const std::string& talkgadget_prefix);
 
+  void StartHostStatusService();
+
   void StartHost();
 
   void OnAuthFailed();
 
   void RejectAuthenticatingClient();
 
   // Invoked when the user uses the Disconnect windows to terminate
   // the sessions, or when the local session is activated in curtain mode.
   void OnDisconnectRequested();
 
@@ skipping 15 matching lines @@
                const int& line_number);
 
   scoped_ptr<ChromotingHostContext> context_;
   scoped_ptr<IPC::ChannelProxy> daemon_channel_;
   scoped_ptr<net::NetworkChangeNotifier> network_change_notifier_;
 
   FilePath host_config_path_;
   scoped_ptr<ConfigFileWatcher> config_watcher_;
 
   // Accessed on the network thread.
+
+  scoped_ptr<HostStatusService> status_service_;
+
   std::string host_id_;
   protocol::SharedSecretHash host_secret_hash_;
   HostKeyPair key_pair_;
   std::string oauth_refresh_token_;
   std::string serialized_config_;
   std::string xmpp_login_;
   std::string xmpp_auth_token_;
   std::string xmpp_auth_service_;
 
   scoped_ptr<policy_hack::PolicyWatcher> policy_watcher_;
@@ skipping 245 matching lines @@
   // If an audio pipe is specific on the command-line then initialize
   // AudioCapturerLinux to capture from it.
   FilePath audio_pipe_name = CommandLine::ForCurrentProcess()->
       GetSwitchValuePath(kAudioPipeSwitchName);
   if (!audio_pipe_name.empty()) {
     remoting::AudioCapturerLinux::InitializePipeReader(
         context_->audio_task_runner(), audio_pipe_name);
   }
 #endif  // defined(OS_LINUX)
 
+  if (CommandLine::ForCurrentProcess()->HasSwitch(
+          kEnableStatusServiceSwitchName)) {
+    context_->network_task_runner()->PostTask(
+        FROM_HERE,
+        base::Bind(&HostProcess::StartHostStatusService,
+                   base::Unretained(this)));
+  }
+
   // Create a desktop environment factory appropriate to the build type &
   // platform.
 #if defined(OS_WIN)
 
 #if defined(REMOTING_MULTI_PROCESS)
   IpcDesktopEnvironmentFactory* desktop_environment_factory =
       new IpcDesktopEnvironmentFactory(
           daemon_channel_.get(),
           context_->input_task_runner(),
           context_->network_task_runner(),
@@ skipping 233 matching lines @@
   DCHECK(context_->network_task_runner()->BelongsToCurrentThread());
 
   if (talkgadget_prefix != talkgadget_prefix_) {
     LOG(INFO) << "Updated talkgadget policy.";
     talkgadget_prefix_ = talkgadget_prefix;
     return true;
   }
   return false;
 }
 
+void HostProcess::StartHostStatusService() {
+  DCHECK(context_->network_task_runner()->BelongsToCurrentThread());
+  status_service_.reset(new HostStatusService());
+}
+
 void HostProcess::StartHost() {
   DCHECK(context_->network_task_runner()->BelongsToCurrentThread());
   DCHECK(!host_);
   DCHECK(!signal_strategy_.get());
 
   if (shutting_down_)
     return;
 
   signal_strategy_.reset(
       new XmppSignalStrategy(context_->url_request_context_getter(),
@@ skipping 60 matching lines @@
   // so it's disabled until we've had time to fully investigate.
   //    curtaining_host_observer_.reset(new CurtainingHostObserver(
   //          curtain_.get(), host_));
 
   if (host_user_interface_.get()) {
     host_user_interface_->Start(
         host_, base::Bind(&HostProcess::OnDisconnectRequested,
                           base::Unretained(this)));
   }
 
+  if (status_service_)
+    status_service_->SetState(true, host_id_);
+
   host_->Start(xmpp_login_);
 
   CreateAuthenticatorFactory();
 }
 
 void HostProcess::OnAuthFailed() {
   Shutdown(kInvalidOauthCredentialsExitCode);
 }
 
 void HostProcess::RejectAuthenticatingClient() {
@@ skipping 38 matching lines @@
 
   StartHost();
 }
 
 void HostProcess::Shutdown(int exit_code) {
   DCHECK(context_->network_task_runner()->BelongsToCurrentThread());
 
   if (shutting_down_)
     return;
 
+  if (status_service_)
+    status_service_->SetState(false, "");

[alexeypa (please no reviews), 2012/11/15 19:45:56]

nit: It may be worth splitting SetState into two separate methods:
SetHostIsUp(host_id) and SetHostIsDown().

[Sergey Ulanov, 2012/11/16 00:52:10]

Done.

+
   shutting_down_ = true;
   exit_code_ = exit_code;
   if (host_) {
     host_->Shutdown(base::Bind(
         &HostProcess::OnShutdownFinished, base::Unretained(this)));
   } else {
     OnShutdownFinished();
   }
 }
 
 void HostProcess::OnShutdownFinished() {
   DCHECK(context_->network_task_runner()->BelongsToCurrentThread());
 
   // Destroy networking objects while we are on the network thread.
   host_ = NULL;
   ResetHost();
 
   if (policy_watcher_.get()) {
     base::WaitableEvent done_event(true, false);
     policy_watcher_->StopWatching(&done_event);
     done_event.Wait();
     policy_watcher_.reset();
   }
 
+  status_service_.reset();
+
   // Complete the rest of shutdown on the main thread.
   context_->ui_task_runner()->PostTask(
       FROM_HERE,
       base::Bind(&HostProcess::ShutdownHostProcess,
                  base::Unretained(this)));
 }
 
 void HostProcess::ResetHost() {
   DCHECK(context_->network_task_runner()->BelongsToCurrentThread());
 
@@ 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)