[Chromoting] Refactor the host policy watcher so that policies can easily be added.

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 23 matching lines @@
 #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/network_settings.h"
-#include "remoting/host/policy_hack/nat_policy.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/jingle_glue/xmpp_signal_strategy.h"
 #include "remoting/protocol/me2me_host_authenticator_factory.h"
 
 #if defined(OS_MACOSX)
 #include "base/mac/scoped_nsautorelease_pool.h"
 #include "remoting/host/sighup_listener_mac.h"
 #endif
@@ skipping 151 matching lines @@
 
   int Run() {
     if (!LoadConfig()) {
       return kInvalidHostConfigurationExitCode;
     }
 
 #if defined(OS_MACOSX) || defined(OS_WIN)
     host_user_interface_.reset(new HostUserInterface(context_.get()));
 #endif
 
-    StartWatchingNatPolicy();
+    StartWatchingPolicy();
 
 #if defined(OS_MACOSX) || defined(OS_WIN)
     context_->file_task_runner()->PostTask(
         FROM_HERE,
         base::Bind(&HostProcess::ListenForConfigChanges,
                    base::Unretained(this)));
 #endif
     message_loop_.Run();
 
 #if defined(OS_MACOSX) || defined(OS_WIN)
     host_user_interface_.reset();
 #endif
 
     base::WaitableEvent done_event(true, false);
-    nat_policy_->StopWatching(&done_event);
+    policy_watcher_->StopWatching(&done_event);
     done_event.Wait();
-    nat_policy_.reset();
+    policy_watcher_.reset();
 
     return exit_code_;
   }
 
   // Overridden from HeartbeatSender::Listener
   virtual void OnUnknownHostIdError() OVERRIDE {
     LOG(ERROR) << "Host ID not found.";
     Shutdown(kInvalidHostIdExitCode);
   }
 
  private:
-  void StartWatchingNatPolicy() {
-    nat_policy_.reset(
-        policy_hack::NatPolicy::Create(context_->file_task_runner()));
-    nat_policy_->StartWatching(
-        base::Bind(&HostProcess::OnNatPolicyUpdate, base::Unretained(this)));
+  void StartWatchingPolicy() {
+    policy_watcher_.reset(
+        policy_hack::PolicyWatcher::Create(context_->file_task_runner()));
+    policy_watcher_->StartWatching(
+        base::Bind(&HostProcess::OnPolicyUpdate, base::Unretained(this)));
   }
 
   // Read Host config from disk, returning true if successful.
   bool LoadConfig() {
     JsonHostConfig host_config(host_config_path_);
     JsonHostConfig auth_config(auth_config_path_);
 
     FilePath failed_path;
     if (!host_config.Read()) {
       failed_path = host_config_path_;
@@ skipping 47 matching lines @@
     } else if (!auth_config.GetString(kXmppAuthServiceConfigPath,
                                       &xmpp_auth_service_)) {
       // For the me2me host, we default to ClientLogin token for chromiumsync
       // because earlier versions of the host had no HTTP stack with which to
       // request an OAuth2 access token.
       xmpp_auth_service_ = kChromotingTokenDefaultServiceName;
     }
     return true;
   }
 
+  void OnPolicyUpdate(scoped_ptr<base::DictionaryValue> policies) {
+    if (!context_->network_task_runner()->BelongsToCurrentThread()) {
+      context_->network_task_runner()->PostTask(FROM_HERE, base::Bind(
+          &HostProcess::OnPolicyUpdate, base::Unretained(this),
+          base::Passed(&policies)));
+      return;
+    }
+
+    bool bool_value;
+    if (policies->GetBoolean(policy_hack::PolicyWatcher::kNatPolicyName,
+                             &bool_value)) {
+      OnNatPolicyUpdate(bool_value);
+    }
+  }
+
   void OnNatPolicyUpdate(bool nat_traversal_enabled) {
     if (!context_->network_task_runner()->BelongsToCurrentThread()) {
       context_->network_task_runner()->PostTask(FROM_HERE, base::Bind(
           &HostProcess::OnNatPolicyUpdate, base::Unretained(this),
           nat_traversal_enabled));
       return;
     }
 
     bool policy_changed = allow_nat_traversal_ != nat_traversal_enabled;
     allow_nat_traversal_ = nat_traversal_enabled;
@@ skipping 164 matching lines @@
   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::NatPolicy> nat_policy_;
+  scoped_ptr<policy_hack::PolicyWatcher> policy_watcher_;
   bool allow_nat_traversal_;
   scoped_ptr<base::files::FilePathWatcher> config_watcher_;
   scoped_ptr<base::DelayTimer<HostProcess> > config_updated_timer_;
 
   bool restarting_;
   bool shutting_down_;
 
   scoped_ptr<XmppSignalStrategy> signal_strategy_;
   scoped_ptr<SignalingConnector> signaling_connector_;
   scoped_ptr<DesktopEnvironment> desktop_environment_;
@@ skipping 91 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)