Remove policy watching from It2MeHost.

remoting/host/it2me/it2me_native_messaging_host.cc

 // Copyright 2013 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/it2me/it2me_native_messaging_host.h"
 
 #include <memory>
 #include <string>
 #include <utility>
 
@@ skipping 65 matching lines @@
 // Called when malformed policies are detected.
 void OnPolicyError() {
   // TODO(joedow): Report the policy error to the user.  crbug.com/433009
   NOTIMPLEMENTED();
 }
 
 }  // namespace
 
 It2MeNativeMessagingHost::It2MeNativeMessagingHost(
     bool needs_elevation,
-    policy::PolicyService* policy_service,
+    std::unique_ptr<PolicyWatcher> policy_watcher,
     std::unique_ptr<ChromotingHostContext> context,
     std::unique_ptr<It2MeHostFactory> factory)
     : needs_elevation_(needs_elevation),
       host_context_(std::move(context)),
       factory_(std::move(factory)),
-      policy_service_(policy_service),
-      policy_watcher_(PolicyWatcher::Create(policy_service_,
-                                            host_context_->file_task_runner())),
+      policy_watcher_(std::move(policy_watcher)),
       weak_factory_(this) {
   weak_ptr_ = weak_factory_.GetWeakPtr();
 
   // The policy watcher runs on the |file_task_runner| but we want to run the
   // update code on |task_runner| so we use a shim to post the callback to the
   // preferred task runner.
   PolicyWatcher::PolicyUpdatedCallback update_callback =
       base::Bind(&It2MeNativeMessagingHost::OnPolicyUpdate, weak_ptr_);
   policy_watcher_->StartWatching(
       base::Bind(&PolicyUpdateCallback, task_runner(), update_callback),
@@ skipping 205 matching lines @@
 
 #if !defined(NDEBUG)
   if (!message->GetString("directoryBotJid", &directory_bot_jid)) {
     SendErrorAndExit(std::move(response),
                      "'directoryBotJid' not found in request.");
     return;
   }
 #endif  // !defined(NDEBUG)
 
   // Create the It2Me host and start connecting.
-  it2me_host_ = factory_->CreateIt2MeHost(
-      host_context_->Copy(), policy_service_, weak_ptr_,
-      std::move(signal_strategy), username, directory_bot_jid);
+  it2me_host_ = factory_->CreateIt2MeHost(host_context_->Copy(), weak_ptr_,
+                                          std::move(signal_strategy), username,
+                                          directory_bot_jid);
+  it2me_host_->OnPolicyUpdate(policy_watcher_->GetCurrentPolicies());
   it2me_host_->Connect();
 
   SendMessageToClient(std::move(response));
 }
 
 void It2MeNativeMessagingHost::ProcessDisconnect(
     std::unique_ptr<base::DictionaryValue> message,
     std::unique_ptr<base::DictionaryValue> response) {
   DCHECK(task_runner()->BelongsToCurrentThread());
   DCHECK(policy_received_);
@@ skipping 129 matching lines @@
 }
 
 /* static */
 std::string It2MeNativeMessagingHost::HostStateToString(
     It2MeHostState host_state) {
   return ValueToName(kIt2MeHostStates, host_state);
 }
 
 void It2MeNativeMessagingHost::OnPolicyUpdate(
     std::unique_ptr<base::DictionaryValue> policies) {
-  if (policy_received_) {
-    // Don't dynamically change how the host operates since we don't have a good
-    // way to communicate changes to the user.
-    return;
+  // Don't dynamically change the elevation status since we don't have a good
+  // way to communicate changes to the user.
+  if (!policy_received_) {
+    bool allow_elevated_host = false;
+    if (!policies->GetBoolean(
+            policy::key::kRemoteAccessHostAllowUiAccessForRemoteAssistance,
+            &allow_elevated_host)) {
+      LOG(WARNING) << "Failed to retrieve elevated host policy value.";
+    }
+#if defined(OS_WIN)
+    LOG(INFO) << "Allow UiAccess for Remote Assistance: "
+              << allow_elevated_host;
+#endif  // defined(OS_WIN)
+
+    policy_received_ = true;
+
+    // If |allow_elevated_host| is false, then we will fall back to using a host
+    // running in the current context regardless of the elevation request.  This
+    // may not be ideal, but is still functional.
+    needs_elevation_ = needs_elevation_ && allow_elevated_host;
+    if (!pending_connect_.is_null()) {

[joedow, 2017/05/05 14:42:15]

nit: the style for this has changed, the preferred syntax is to treat the var as
a bool:
if (pending_connect_) {

[Jamie, 2017/05/05 16:49:05]

Done, here and above.

+      base::ResetAndReturn(&pending_connect_).Run();
+    }
   }
 
-  bool allow_elevated_host = false;
-  if (!policies->GetBoolean(
-          policy::key::kRemoteAccessHostAllowUiAccessForRemoteAssistance,
-          &allow_elevated_host)) {
-    LOG(WARNING) << "Failed to retrieve elevated host policy value.";
-  }
-#if defined(OS_WIN)
-  LOG(INFO) << "Allow UiAccess for Remote Assistance: " << allow_elevated_host;
-#endif  // defined(OS_WIN)
-
-  policy_received_ = true;
-
-  // If |allow_elevated_host| is false, then we will fall back to using a host
-  // running in the current context regardless of the elevation request.  This
-  // may not be ideal, but is still functional.
-  needs_elevation_ = needs_elevation_ && allow_elevated_host;
-  if (!pending_connect_.is_null()) {
-    base::ResetAndReturn(&pending_connect_).Run();
+  if (it2me_host_.get()) {
+    it2me_host_->OnPolicyUpdate(std::move(policies));
   }
 }
 
 #if defined(OS_WIN)
 
 bool It2MeNativeMessagingHost::DelegateToElevatedHost(
     std::unique_ptr<base::DictionaryValue> message) {
   DCHECK(task_runner()->BelongsToCurrentThread());
   DCHECK(needs_elevation_);
 
@@ skipping 24 matching lines @@
 
 bool It2MeNativeMessagingHost::DelegateToElevatedHost(
     std::unique_ptr<base::DictionaryValue> message) {
   NOTREACHED();
   return false;
 }
 
 #endif  // !defined(OS_WIN)
 
 }  // namespace remoting