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

remoting/host/plugin/host_script_object.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.
 
 #include "remoting/host/plugin/host_script_object.h"
 
 #include "base/bind.h"
 #include "base/json/json_reader.h"
 #include "base/json/json_writer.h"
 #include "base/message_loop.h"
 #include "base/message_loop_proxy.h"
 #include "base/sys_string_conversions.h"
 #include "base/threading/platform_thread.h"
 #include "base/utf_string_conversions.h"
 #include "base/values.h"
 #include "net/base/net_util.h"
 #include "remoting/base/auth_token_util.h"
 #include "remoting/host/chromoting_host.h"
 #include "remoting/host/chromoting_host_context.h"
 #include "remoting/host/desktop_environment.h"
 #include "remoting/host/host_config.h"
 #include "remoting/host/host_key_pair.h"
 #include "remoting/host/host_secret.h"
 #include "remoting/host/it2me_host_user_interface.h"
 #include "remoting/host/network_settings.h"
 #include "remoting/host/pin_hash.h"
 #include "remoting/host/plugin/daemon_controller.h"
 #include "remoting/host/plugin/host_log_handler.h"
-#include "remoting/host/policy_hack/nat_policy.h"
+#include "remoting/host/policy_hack/policy_watcher.h"
 #include "remoting/host/register_support_host_request.h"
 #include "remoting/host/session_manager_factory.h"
 #include "remoting/jingle_glue/xmpp_signal_strategy.h"
 #include "remoting/protocol/it2me_host_authenticator_factory.h"
 
 namespace remoting {
 
 namespace {
 
 const char* kAttrNameAccessCode = "accessCode";
@@ skipping 57 matching lines @@
 }
 
 HostNPScriptObject::~HostNPScriptObject() {
   CHECK_EQ(base::PlatformThread::CurrentId(), np_thread_id_);
 
   HostLogHandler::UnregisterLoggingScriptObject(this);
 
   plugin_task_runner_->Detach();
 
   // Stop listening for policy updates.
-  if (nat_policy_.get()) {
-    base::WaitableEvent nat_policy_stopped_(true, false);
-    nat_policy_->StopWatching(&nat_policy_stopped_);
-    nat_policy_stopped_.Wait();
-    nat_policy_.reset();
+  if (policy_watcher_.get()) {
+    base::WaitableEvent policy_watcher_stopped_(true, false);
+    policy_watcher_->StopWatching(&policy_watcher_stopped_);
+    policy_watcher_stopped_.Wait();
+    policy_watcher_.reset();
   }
 
   if (host_context_.get()) {
     // Disconnect synchronously. We cannot disconnect asynchronously
     // here because |host_context_| needs to be stopped on the plugin
     // thread, but the plugin thread may not exist after the instance
     // is destroyed.
     disconnected_event_.Reset();
     DisconnectInternal();
     disconnected_event_.Wait();
@@ skipping 15 matching lines @@
 bool HostNPScriptObject::Init() {
   DCHECK(plugin_task_runner_->BelongsToCurrentThread());
   VLOG(2) << "Init";
 
   host_context_.reset(new ChromotingHostContext(plugin_task_runner_));
   if (!host_context_->Start()) {
     host_context_.reset();
     return false;
   }
 
-  nat_policy_.reset(
-      policy_hack::NatPolicy::Create(host_context_->network_task_runner()));
-  nat_policy_->StartWatching(
-      base::Bind(&HostNPScriptObject::OnNatPolicyUpdate,
+  policy_watcher_.reset(
+      policy_hack::PolicyWatcher::Create(host_context_->network_task_runner()));
+  policy_watcher_->StartWatching(
+      base::Bind(&HostNPScriptObject::OnPolicyUpdate,
                  base::Unretained(this)));
   return true;
 }
 
 bool HostNPScriptObject::HasMethod(const std::string& method_name) {
   VLOG(2) << "HasMethod " << method_name;
   CHECK_EQ(base::PlatformThread::CurrentId(), np_thread_id_);
   return (method_name == kFuncNameConnect ||
           method_name == kFuncNameDisconnect ||
           method_name == kFuncNameLocalize ||
@@ skipping 723 matching lines @@
                          base::Unretained(this))));
   }
 }
 
 void HostNPScriptObject::OnShutdownFinished() {
   DCHECK(host_context_->network_task_runner()->BelongsToCurrentThread());
 
   disconnected_event_.Signal();
 }
 
+void HostNPScriptObject::OnPolicyUpdate(
+    scoped_ptr<base::DictionaryValue> policies) {
+  if (!host_context_->network_task_runner()->BelongsToCurrentThread()) {
+    host_context_->network_task_runner()->PostTask(
+        FROM_HERE,
+        base::Bind(&HostNPScriptObject::OnPolicyUpdate,
+                   base::Unretained(this), base::Passed(&policies)));
+    return;
+  }
+
+  bool bool_value;
+  if (policies->GetBoolean(policy_hack::PolicyWatcher::kNatPolicyName,
+                           &bool_value)) {
+    OnNatPolicyUpdate(bool_value);
+  }
+}
+
 void HostNPScriptObject::OnNatPolicyUpdate(bool nat_traversal_enabled) {
   if (!host_context_->network_task_runner()->BelongsToCurrentThread()) {
     host_context_->network_task_runner()->PostTask(
         FROM_HERE,
         base::Bind(&HostNPScriptObject::OnNatPolicyUpdate,
                    base::Unretained(this), nat_traversal_enabled));
     return;
   }
 
   VLOG(2) << "OnNatPolicyUpdate: " << nat_traversal_enabled;
@@ skipping 322 matching lines @@
   return is_good;
 }
 
 void HostNPScriptObject::SetException(const std::string& exception_string) {
   DCHECK(plugin_task_runner_->BelongsToCurrentThread());
   g_npnetscape_funcs->setexception(parent_, exception_string.c_str());
   LOG(INFO) << exception_string;
 }
 
 }  // namespace remoting