Remove policy watching from It2MeHost.

remoting/host/it2me/it2me_host_unittest.cc

 // Copyright 2016 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_host.h"
 
 #include <memory>
 #include <string>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/callback_helpers.h"
 #include "base/location.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/weak_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "base/threading/thread_task_runner_handle.h"
-#include "components/policy/core/common/fake_async_policy_loader.h"
 #include "components/policy/policy_constants.h"
 #include "remoting/base/auto_thread_task_runner.h"
 #include "remoting/host/chromoting_host_context.h"
 #include "remoting/host/it2me/it2me_confirmation_dialog.h"
 #include "remoting/host/policy_watcher.h"
 #include "remoting/signaling/fake_signal_strategy.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace remoting {
 
@@ skipping 132 matching lines @@
  private:
   void StartupHostStateHelper(const base::Closure& quit_closure);
 
   std::unique_ptr<base::MessageLoop> message_loop_;
   std::unique_ptr<base::RunLoop> run_loop_;
 
   scoped_refptr<AutoThreadTaskRunner> network_task_runner_;
   scoped_refptr<AutoThreadTaskRunner> ui_task_runner_;
 
   scoped_refptr<It2MeHost> it2me_host_;
-  // The FakeAsyncPolicyLoader is owned by it2me_host_, but we retain a raw
-  // pointer so we can control the policy contents.
-  policy::FakeAsyncPolicyLoader* policy_loader_ = nullptr;
 
   base::WeakPtrFactory<It2MeHostTest> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(It2MeHostTest);
 };
 
 It2MeHostTest::It2MeHostTest() : weak_factory_(this) {}
 
 It2MeHostTest::~It2MeHostTest() {}
 
 void It2MeHostTest::SetUp() {
   message_loop_.reset(new base::MessageLoop());
   run_loop_.reset(new base::RunLoop());
 
   std::unique_ptr<ChromotingHostContext> host_context(
       ChromotingHostContext::Create(new AutoThreadTaskRunner(
           base::ThreadTaskRunnerHandle::Get(), run_loop_->QuitClosure())));
   network_task_runner_ = host_context->network_task_runner();
   ui_task_runner_ = host_context->ui_task_runner();
 
   std::unique_ptr<FakeIt2MeDialogFactory> dialog_factory(
       new FakeIt2MeDialogFactory());
   dialog_factory_ = dialog_factory.get();
-  policy_loader_ =
-      new policy::FakeAsyncPolicyLoader(base::ThreadTaskRunnerHandle::Get());
   it2me_host_ = new It2MeHost(
       std::move(host_context),
-      PolicyWatcher::CreateFromPolicyLoaderForTesting(
-          base::WrapUnique(policy_loader_)),
       std::move(dialog_factory), weak_factory_.GetWeakPtr(),
       base::WrapUnique(
           new FakeSignalStrategy(SignalingAddress("fake_local_jid"))),
       kTestUserName, "fake_bot_jid");
+
+  it2me_host_->OnPolicyUpdate(PolicyWatcher::GetDefaultPolicies());
 }
 
 void It2MeHostTest::TearDown() {
   // Shutdown the host if it hasn't been already. Without this, the call to
   // run_loop_->Run() may never return.
   it2me_host_->Disconnect();
   network_task_runner_ = nullptr;
   ui_task_runner_ = nullptr;
   it2me_host_ = nullptr;
   run_loop_->Run();
 }
 
 void It2MeHostTest::OnValidationComplete(const base::Closure& resume_callback,
                                          ValidationResult validation_result) {
   validation_result_ = validation_result;
 
   ui_task_runner_->PostTask(FROM_HERE, resume_callback);
 }
 
 void It2MeHostTest::SetPolicies(
     std::initializer_list<std::pair<base::StringPiece, const base::Value&>>
         policies) {
-  policy::PolicyBundle bundle;
-  policy::PolicyMap& map = bundle.Get(
-      policy::PolicyNamespace(policy::POLICY_DOMAIN_CHROME, std::string()));
+  auto dictionary = base::MakeUnique<base::DictionaryValue>();
   for (const auto& policy : policies) {
-    map.Set(policy.first.as_string(), policy::POLICY_LEVEL_MANDATORY,
-            policy::POLICY_SCOPE_MACHINE, policy::POLICY_SOURCE_PLATFORM,
-            policy.second.CreateDeepCopy(), nullptr);
+    dictionary->Set(policy.first, policy.second.CreateDeepCopy());
   }
-  policy_loader_->SetPolicies(bundle);
-  policy_loader_->PostReloadOnBackgroundThread(true);
-  base::RunLoop().RunUntilIdle();
+  it2me_host_->OnPolicyUpdate(std::move(dictionary));
 }
 
 void It2MeHostTest::StartupHostStateHelper(const base::Closure& quit_closure) {
   if (last_host_state_ == It2MeHostState::kRequestedAccessCode) {
     network_task_runner_->PostTask(
         FROM_HERE,
         base::Bind(&It2MeHost::SetStateForTesting, it2me_host_.get(),
                    It2MeHostState::kReceivedAccessCode, std::string()));
   } else if (last_host_state_ != It2MeHostState::kStarting) {
     quit_closure.Run();
@@ skipping 279 matching lines @@
   ASSERT_EQ(ValidationResult::SUCCESS, validation_result_);
   ASSERT_EQ(It2MeHostState::kConnecting, last_host_state_);
 
   RunValidationCallback(kTestClientJid2);
   ASSERT_EQ(ValidationResult::ERROR_TOO_MANY_CONNECTIONS, validation_result_);
   RunUntilStateChanged(It2MeHostState::kDisconnected);
   ASSERT_EQ(It2MeHostState::kDisconnected, last_host_state_);
 }
 
 }  // namespace remoting