Making the me2me host compiling and running on Windows. This includes making it a window applicatio…

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, which is currently
 // used for the Linux-only Virtual Me2Me build.
 
+#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/logging.h"
 #include "base/message_loop.h"
+#include "base/path_service.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/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"
@@ skipping 24 matching lines @@
 const FilePath::CharType kDefaultConfigDir[] =
     FILE_PATH_LITERAL(".config/chrome-remote-desktop");
 const FilePath::CharType kDefaultAuthConfigFile[] =
     FILE_PATH_LITERAL("auth.json");
 const FilePath::CharType kDefaultHostConfigFile[] =
     FILE_PATH_LITERAL("host.json");
 
 const int kMinPortNumber = 12400;
 const int kMaxPortNumber = 12409;
 
+FilePath GetDefaultConfigDir() {
+  FilePath default_config_dir;
+
+#if defined(OS_WIN)
+  PathService::Get(base::DIR_PROFILE, &default_config_dir);
+#else
+  default_config_dir = file_util::GetHomeDir();
+#endif
+
+  return default_config_dir.Append(kDefaultConfigDir);
+}
+
 }  // namespace
 
 namespace remoting {
 
 class HostProcess {
  public:
   HostProcess()
       : message_loop_(MessageLoop::TYPE_UI),
         file_io_thread_("FileIO"),
         context_(message_loop_.message_loop_proxy()),
         allow_nat_traversal_(true),
         restarting_(false) {
     context_.Start();
     file_io_thread_.StartWithOptions(
         base::Thread::Options(MessageLoop::TYPE_IO, 0));
     network_change_notifier_.reset(net::NetworkChangeNotifier::Create());
   }
 
   void InitWithCommandLine(const CommandLine* cmd_line) {
-    FilePath default_config_dir =
-        file_util::GetHomeDir().Append(kDefaultConfigDir);
-
+    FilePath default_config_dir = GetDefaultConfigDir();
     if (cmd_line->HasSwitch(kAuthConfigSwitchName)) {
       auth_config_path_ = cmd_line->GetSwitchValuePath(kAuthConfigSwitchName);
     } else {
       auth_config_path_ = default_config_dir.Append(kDefaultAuthConfigFile);
     }
 
     if (cmd_line->HasSwitch(kHostConfigSwitchName)) {
       host_config_path_ = cmd_line->GetSwitchValuePath(kHostConfigSwitchName);
     } else {
       host_config_path_ = default_config_dir.Append(kDefaultHostConfigFile);
@@ skipping 20 matching lines @@
   }
 
  private:
   // Read Host config from disk, returning true if successful.
   bool LoadConfig(base::MessageLoopProxy* io_message_loop) {
     scoped_refptr<JsonHostConfig> host_config =
         new JsonHostConfig(host_config_path_, io_message_loop);
     scoped_refptr<JsonHostConfig> auth_config =
         new JsonHostConfig(auth_config_path_, io_message_loop);
 
-    std::string failed_path;
+    FilePath failed_path;
     if (!host_config->Read()) {
-      failed_path = host_config_path_.value();
+      failed_path = host_config_path_;
     } else if (!auth_config->Read()) {
-      failed_path = auth_config_path_.value();
+      failed_path = auth_config_path_;
     }
     if (!failed_path.empty()) {
-      LOG(ERROR) << "Failed to read configuration file " << failed_path;
+      LOG(ERROR) << "Failed to read configuration file " << failed_path.value();
       return false;
     }
 
     if (!host_config->GetString(kHostIdConfigPath, &host_id_)) {
       LOG(ERROR) << "host_id is not defined in the config.";
       return false;
     }
 
     if (!key_pair_.Load(host_config)) {
       return false;
@@ skipping 75 matching lines @@
 
     host_ = new ChromotingHost(
         &context_, signal_strategy_.get(), desktop_environment_.get(),
         network_settings);
 
     heartbeat_sender_.reset(
         new HeartbeatSender(host_id_, signal_strategy_.get(), &key_pair_));
 
     log_to_server_.reset(
         new LogToServer(host_, ServerLogEntry::ME2ME, signal_strategy_.get()));
-    host_event_logger_.reset(new HostEventLogger(host_, kApplicationName));
+    host_event_logger_ = HostEventLogger::Create(host_, kApplicationName);
 
     host_->Start();
 
     // Create authenticator factory.
     scoped_ptr<protocol::AuthenticatorFactory> factory(
         new protocol::Me2MeHostAuthenticatorFactory(
             xmpp_login_, key_pair_.GenerateCertificate(),
             *key_pair_.private_key(), host_secret_hash_));
     host_->SetAuthenticatorFactory(factory.Pass());
   }
@@ skipping 67 matching lines @@
   // Continue windows, though these should not be used for the Me2Me case
   // (crbug.com/104377).
   gfx::GtkInitFromCommandLine(*cmd_line);
 #endif  // TOOLKIT_USES_GTK
 
   remoting::HostProcess me2me_host;
   me2me_host.InitWithCommandLine(cmd_line);
 
   return me2me_host.Run();
 }
+
+#if defined(OS_WIN)
+
+int CALLBACK WinMain(HINSTANCE instance,
+                     HINSTANCE previous_instance,
+                     LPSTR command_line,
+                     int show_command) {
+  // 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