[Chromoting] Implement UpdateConfig() for the Windows 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.
 
 #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/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/capturer.h"
@@ skipping 52 matching lines @@
         allow_nat_traversal_(true),
         restarting_(false) {
     file_io_thread_.StartWithOptions(
         base::Thread::Options(MessageLoop::TYPE_IO, 0));
 
     context_.reset(new ChromotingHostContext(
                            file_io_thread_.message_loop_proxy(),
                            message_loop_.message_loop_proxy()));
     context_->Start();
     network_change_notifier_.reset(net::NetworkChangeNotifier::Create());
+    config_updated_timer_.reset(new base::DelayTimer<HostProcess>(

[Sergey Ulanov, 2012/04/17 05:42:18]

Add a comment here or in OnFilePathChanged() to explain what we need this delay
for.

[simonmorris, 2012/04/17 15:55:47]

Done.

+        FROM_HERE, base::TimeDelta::FromSeconds(2), this,
+        &HostProcess::ConfigUpdated));
   }
 
   void InitWithCommandLine(const CommandLine* cmd_line) {
     FilePath default_config_dir = remoting::GetConfigDir();
     if (cmd_line->HasSwitch(kAuthConfigSwitchName)) {
       auth_config_path_ = cmd_line->GetSwitchValuePath(kAuthConfigSwitchName);
     } else {
       auth_config_path_ = default_config_dir.Append(kDefaultAuthConfigFile);
     }
 
@@ skipping 15 matching lines @@
     if (LoadConfig(file_io_thread_.message_loop_proxy(), &tokens_pending)) {
       context_->network_message_loop()->PostTask(
           FROM_HERE,
           base::Bind(&HostProcess::CreateAuthenticatorFactory,
                      base::Unretained(this)));
     } else {
       LOG(ERROR) << "Invalid configuration.";
     }
   }
 
+#if defined(OS_WIN)
+  class ConfigChangedDelegate : public base::files::FilePathWatcher::Delegate {
+   public:
+    ConfigChangedDelegate(HostProcess* host_process) :
+      host_process_(host_process) {
+    }
+    void OnFilePathChanged(const FilePath& path) OVERRIDE {
+      host_process_->config_updated_timer_->Reset();
+    }
+    void OnFilePathError(const FilePath& path) OVERRIDE {
+    }
+   private:
+    HostProcess* host_process_;
+
+    DISALLOW_COPY_AND_ASSIGN(ConfigChangedDelegate);
+  };
+#endif  // defined(OS_WIN)
+
+  void ListenForConfigChanges() {
 #if defined(OS_MACOSX)
-  void ListenForConfigChanges() {
     remoting::RegisterHupSignalHandler(
         base::Bind(&HostProcess::ConfigUpdated, base::Unretained(this)));
+#elif defined(OS_WIN)
+    scoped_refptr<base::files::FilePathWatcher::Delegate> delegate(
+        new ConfigChangedDelegate(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
   }
-#endif
 
   void CreateAuthenticatorFactory() {
     scoped_ptr<protocol::AuthenticatorFactory> factory(
         new protocol::Me2MeHostAuthenticatorFactory(
             xmpp_login_, key_pair_.GenerateCertificate(),
             *key_pair_.private_key(), host_secret_hash_));
     host_->SetAuthenticatorFactory(factory.Pass());
   }
 
   int Run() {
     bool tokens_pending = false;
     if (!LoadConfig(file_io_thread_.message_loop_proxy(), &tokens_pending)) {
       return kInvalidHostConfigurationExitCode;
     }
     if (tokens_pending) {
       // If we have an OAuth refresh token, then XmppSignalStrategy can't
       // handle it directly, so refresh it asynchronously. A task will be
       // posted on the message loop to start watching the NAT policy when
       // the access token is available.
       //
       // TODO(sergeyu): Move this code to SignalingConnector.
       oauth_client_.Start(oauth_refresh_token_, this,
                           message_loop_.message_loop_proxy());
     } else {
       StartWatchingNatPolicy();
     }
 
-#if defined(OS_MACOSX)
+#if defined(OS_MACOSX) || defined(OS_WIN)
     file_io_thread_.message_loop_proxy()->PostTask(
         FROM_HERE,
         base::Bind(&HostProcess::ListenForConfigChanges,
                    base::Unretained(this)));
 #endif
     message_loop_.Run();
 
     return kSuccessExitCode;
   }
 
@@ skipping 185 matching lines @@
   protocol::SharedSecretHash host_secret_hash_;
   std::string xmpp_login_;
   std::string xmpp_auth_token_;
   std::string xmpp_auth_service_;
 
   std::string oauth_refresh_token_;
   OAuthClient oauth_client_;
 
   scoped_ptr<policy_hack::NatPolicy> nat_policy_;
   bool allow_nat_traversal_;
+  scoped_ptr<base::files::FilePathWatcher> config_watcher_;
+  scoped_ptr<base::DelayTimer<HostProcess> > config_updated_timer_;
 
   bool restarting_;
 
   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_;
   scoped_refptr<ChromotingHost> host_;
@@ skipping 39 matching lines @@
 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