Chromoting: the Me2me host now presents a notification on the console allowing a user to disconnect…

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.
 
-#if defined(OS_WIN)
-#include <windows.h>
-#endif
-
 #include <string>
 
 #include "base/at_exit.h"
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/command_line.h"
 #include "base/file_path.h"
 #include "base/file_util.h"
 #include "base/files/file_path_watcher.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/threading/thread.h"
 #include "build/build_config.h"
 #include "crypto/nss_util.h"
 #include "net/base/network_change_notifier.h"
 #include "remoting/base/constants.h"
 #include "remoting/host/branding.h"
 #include "remoting/host/constants.h"
 #include "remoting/host/capturer.h"
 #include "remoting/host/chromoting_host.h"
 #include "remoting/host/chromoting_host_context.h"
 #include "remoting/host/desktop_environment.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_user_interface.h"
 #include "remoting/host/json_host_config.h"
 #include "remoting/host/log_to_server.h"
 #include "remoting/host/policy_hack/nat_policy.h"
 #include "remoting/host/signaling_connector.h"
 #include "remoting/jingle_glue/xmpp_signal_strategy.h"
 #include "remoting/protocol/me2me_host_authenticator_factory.h"
 
 #if defined(OS_MACOSX)
 #include "remoting/host/sighup_listener_mac.h"
 #endif
+// N.B. OS_WIN is defined by including src/base headers.
+#if defined(OS_WIN)
+#include <commctrl.h>
+#endif
 #if defined(TOOLKIT_GTK)
 #include "ui/gfx/gtk_util.h"
 #endif
 
 namespace {
 
 // This is used for tagging system event logs.
 const char kApplicationName[] = "chromoting";
 
 // These are used for parsing the config-file locations from the command line,
@@ skipping 132 matching lines @@
             xmpp_login_, key_pair_.GenerateCertificate(),
             *key_pair_.private_key(), host_secret_hash_));
     host_->SetAuthenticatorFactory(factory.Pass());
   }
 
   int Run() {
     if (!LoadConfig()) {
       return kInvalidHostConfigurationExitCode;
     }
 
+#if defined(OS_WIN)
+    host_user_interface_.reset(new HostUserInterface(context_.get()));
+#endif
+
     StartWatchingNatPolicy();
 
 #if defined(OS_MACOSX) || defined(OS_WIN)
     context_->file_message_loop()->PostTask(
         FROM_HERE,
         base::Bind(&HostProcess::ListenForConfigChanges,
                    base::Unretained(this)));
 #endif
     message_loop_.Run();
 
+#if defined(OS_WIN)
+    host_user_interface_.reset();
+#endif
+
     base::WaitableEvent done_event(true, false);
     nat_policy_->StopWatching(&done_event);
     done_event.Wait();
     nat_policy_.reset();
 
     return exit_code_;
   }
 
   // Overridden from HeartbeatSender::Listener
   virtual void OnUnknownHostIdError() OVERRIDE {
@@ skipping 153 matching lines @@
         context_.get(), signal_strategy_.get(), desktop_environment_.get(),
         network_settings);
 
     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_WIN)
+    host_user_interface_->Start(
+        host_,
+        base::Bind(&HostProcess::OnRestartHostRequest, base::Unretained(this)));
+#endif
+
     host_->Start();
 
     CreateAuthenticatorFactory();
   }
 
   void OnOAuthFailed() {
     Shutdown(kInvalidOauthCredentialsExitCode);
   }
 
+  // Invoked from when the user uses the Disconnect windows to terminate
+  // the sessions.
+  void OnRestartHostRequest() {
+    DCHECK(message_loop_.message_loop_proxy()->BelongsToCurrentThread());
+
+    context_->network_message_loop()->PostTask(
+        FROM_HERE,
+        base::Bind(&HostProcess::RestartHost, base::Unretained(this)));
+  }
+
   void RestartHost() {
     DCHECK(context_->network_message_loop()->BelongsToCurrentThread());
 
     if (restarting_ || shutting_down_)
       return;
 
     restarting_ = true;
     host_->Shutdown(base::Bind(
         &HostProcess::RestartOnHostShutdown, base::Unretained(this)));
   }
@@ skipping 63 matching lines @@
 
   bool restarting_;
   bool shutting_down_;
 
   scoped_ptr<XmppSignalStrategy> signal_strategy_;
   scoped_ptr<SignalingConnector> signaling_connector_;
   scoped_ptr<DesktopEnvironment> desktop_environment_;
   scoped_ptr<HeartbeatSender> heartbeat_sender_;
   scoped_ptr<LogToServer> log_to_server_;
   scoped_ptr<HostEventLogger> host_event_logger_;
+
+#if defined(OS_WIN)
+  scoped_ptr<HostUserInterface> host_user_interface_;
+#endif
+
   scoped_refptr<ChromotingHost> host_;
 
   int exit_code_;
 };
 
 }  // namespace remoting
 
 int main(int argc, char** argv) {
   CommandLine::Init(argc, argv);
 
@@ skipping 24 matching lines @@
   gfx::GtkInitFromCommandLine(*cmd_line);
 #endif  // TOOLKIT_GTK
 
   remoting::HostProcess me2me_host;
   me2me_host.InitWithCommandLine(cmd_line);
 
   return me2me_host.Run();
 }
 
 #if defined(OS_WIN)
+HMODULE g_hModule = NULL;
 
 int CALLBACK WinMain(HINSTANCE instance,
                      HINSTANCE previous_instance,
                      LPSTR command_line,
                      int show_command) {
+  g_hModule = instance;
+
+  // Register and initialize common controls.
+  INITCOMMONCONTROLSEX info;
+  info.dwSize = sizeof(info);
+  info.dwICC = ICC_STANDARD_CLASSES;
+  InitCommonControlsEx(&info);
+
   // 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)