Remove policy watching from It2MeHost.

remoting/host/it2me/it2me_native_messaging_host_unittest.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 <cstdint>
 #include <memory>
 #include <string>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/compiler_specific.h"
 #include "base/json/json_reader.h"
 #include "base/json/json_writer.h"
 #include "base/location.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "base/stl_util.h"
 #include "base/strings/stringize_macros.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "base/values.h"
+#include "components/policy/core/common/fake_async_policy_loader.h"
 #include "components/policy/core/common/mock_policy_service.h"
 #include "net/base/file_stream.h"
 #include "remoting/base/auto_thread_task_runner.h"
 #include "remoting/host/chromoting_host_context.h"
 #include "remoting/host/native_messaging/log_message_handler.h"
 #include "remoting/host/native_messaging/native_messaging_pipe.h"
 #include "remoting/host/native_messaging/pipe_messaging_channel.h"
 #include "remoting/host/policy_watcher.h"
 #include "remoting/host/setup/test_util.h"
 #include "testing/gtest/include/gtest/gtest.h"
@@ skipping 33 matching lines @@
 
   std::string string_value;
   EXPECT_TRUE(response->GetString("type", &string_value));
   EXPECT_EQ(type, string_value);
 
   int int_value;
   EXPECT_TRUE(response->GetInteger("id", &int_value));
   EXPECT_EQ(id, int_value);
 }
 
-class FakePolicyService : public policy::PolicyService {
- public:
-  FakePolicyService();
-  ~FakePolicyService() override;
-
-  // policy::PolicyService overrides.
-  void AddObserver(policy::PolicyDomain domain,
-                   policy::PolicyService::Observer* observer) override;
-  void RemoveObserver(policy::PolicyDomain domain,
-                      policy::PolicyService::Observer* observer) override;
-  const policy::PolicyMap& GetPolicies(
-      const policy::PolicyNamespace& ns) const override;
-  bool IsInitializationComplete(policy::PolicyDomain domain) const override;
-  void RefreshPolicies(const base::Closure& callback) override;
-
- private:
-  policy::PolicyMap policy_map_;
-
-  DISALLOW_COPY_AND_ASSIGN(FakePolicyService);
-};
-
-FakePolicyService::FakePolicyService() {}
-
-FakePolicyService::~FakePolicyService() {}
-
-void FakePolicyService::AddObserver(policy::PolicyDomain domain,
-                                    policy::PolicyService::Observer* observer) {
-}
-
-void FakePolicyService::RemoveObserver(
-    policy::PolicyDomain domain,
-    policy::PolicyService::Observer* observer) {}
-
-const policy::PolicyMap& FakePolicyService::GetPolicies(
-    const policy::PolicyNamespace& ns) const {
-  return policy_map_;
-}
-
-bool FakePolicyService::IsInitializationComplete(
-    policy::PolicyDomain domain) const {
-  return true;
-}
-
-void FakePolicyService::RefreshPolicies(const base::Closure& callback) {
-  base::ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE, callback);
-}
-
 class MockIt2MeHost : public It2MeHost {
  public:
   MockIt2MeHost(std::unique_ptr<ChromotingHostContext> context,
-                std::unique_ptr<PolicyWatcher> policy_watcher,
                 base::WeakPtr<It2MeHost::Observer> observer,
                 std::unique_ptr<SignalStrategy> signal_strategy,
                 const std::string& username,
                 const std::string& directory_bot_jid)
       : It2MeHost(std::move(context),
-                  std::move(policy_watcher),
                   /*confirmation_dialog_factory=*/nullptr,
                   observer,
                   std::move(signal_strategy),
                   username,
                   directory_bot_jid) {}
 
   // It2MeHost overrides
   void Connect() override;
   void Disconnect() override;
   void RequestNatPolicy() override;
@@ skipping 56 matching lines @@
   }
 }
 
 class MockIt2MeHostFactory : public It2MeHostFactory {
  public:
   MockIt2MeHostFactory();
   ~MockIt2MeHostFactory() override;
 
   scoped_refptr<It2MeHost> CreateIt2MeHost(
       std::unique_ptr<ChromotingHostContext> context,
-      policy::PolicyService* policy_service,
       base::WeakPtr<It2MeHost::Observer> observer,
       std::unique_ptr<SignalStrategy> signal_strategy,
       const std::string& username,
       const std::string& directory_bot_jid) override;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(MockIt2MeHostFactory);
 };
 
 MockIt2MeHostFactory::MockIt2MeHostFactory() : It2MeHostFactory() {}
 
 MockIt2MeHostFactory::~MockIt2MeHostFactory() {}
 
 scoped_refptr<It2MeHost> MockIt2MeHostFactory::CreateIt2MeHost(
     std::unique_ptr<ChromotingHostContext> context,
-    policy::PolicyService* policy_service,
     base::WeakPtr<It2MeHost::Observer> observer,
     std::unique_ptr<SignalStrategy> signal_strategy,
     const std::string& username,
     const std::string& directory_bot_jid) {
-  return new MockIt2MeHost(std::move(context),
-                           /*policy_watcher=*/nullptr, observer,
+  return new MockIt2MeHost(std::move(context), observer,
                            std::move(signal_strategy), username,
                            directory_bot_jid);
 }
 
 }  // namespace
 
 class It2MeNativeMessagingHostTest : public testing::Test {
  public:
   It2MeNativeMessagingHostTest() {}
   ~It2MeNativeMessagingHostTest() override {}
@@ skipping 34 matching lines @@
   std::unique_ptr<base::MessageLoop> test_message_loop_;
   std::unique_ptr<base::RunLoop> test_run_loop_;
 
   std::unique_ptr<base::Thread> host_thread_;
   std::unique_ptr<base::RunLoop> host_run_loop_;
 
   // Task runner of the host thread.
   scoped_refptr<AutoThreadTaskRunner> host_task_runner_;
   std::unique_ptr<remoting::NativeMessagingPipe> pipe_;
 
-  std::unique_ptr<policy::PolicyService> fake_policy_service_;
-
   DISALLOW_COPY_AND_ASSIGN(It2MeNativeMessagingHostTest);
 };
 
 void It2MeNativeMessagingHostTest::SetUp() {
   test_message_loop_.reset(new base::MessageLoop());
   test_run_loop_.reset(new base::RunLoop());
 
-#if defined(OS_CHROMEOS)
-  // On Chrome OS, the browser owns the PolicyService so simulate that here.
-  fake_policy_service_.reset(new FakePolicyService());
-#endif  // defined(OS_CHROMEOS)
-
   // Run the host on a dedicated thread.
   host_thread_.reset(new base::Thread("host_thread"));
   host_thread_->Start();
 
   host_task_runner_ = new AutoThreadTaskRunner(
       host_thread_->task_runner(),
       base::Bind(&It2MeNativeMessagingHostTest::ExitTest,
                  base::Unretained(this)));
 
   host_task_runner_->PostTask(
@@ skipping 80 matching lines @@
   VerifyCommonProperties(std::move(response), "helloResponse", request_id);
 }
 
 void It2MeNativeMessagingHostTest::VerifyErrorResponse() {
   std::unique_ptr<base::DictionaryValue> response = ReadMessageFromOutputPipe();
   VerifyStringProperty(std::move(response), "type", "error");
 }
 
 void It2MeNativeMessagingHostTest::VerifyConnectResponses(int request_id) {
   bool connect_response_received = false;
+  bool nat_policy_received = false;
   bool starting_received = false;
   bool requestedAccessCode_received = false;
   bool receivedAccessCode_received = false;
   bool connecting_received = false;
   bool connected_received = false;
 
-  // We expect a total of 6 messages: 1 connectResponse and 5 hostStateChanged.
-  for (int i = 0; i < 6; ++i) {
+  // We expect a total of 7 messages: 1 connectResponse, 1 natPolicyChanged,
+  // and 5 hostStateChanged.
+  for (int i = 0; i < 7; ++i) {
     std::unique_ptr<base::DictionaryValue> response =
         ReadMessageFromOutputPipe();
     ASSERT_TRUE(response);
 
     std::string type;
     ASSERT_TRUE(response->GetString("type", &type));
 
     if (type == "connectResponse") {
       EXPECT_FALSE(connect_response_received);
       connect_response_received = true;
       VerifyId(std::move(response), request_id);
+    } else if (type == "natPolicyChanged") {
+      EXPECT_FALSE(nat_policy_received);
+      nat_policy_received = true;
     } else if (type == "hostStateChanged") {
       std::string state;
       ASSERT_TRUE(response->GetString("state", &state));
 
       std::string value;
       if (state == It2MeNativeMessagingHost::HostStateToString(kStarting)) {
         EXPECT_FALSE(starting_received);
         starting_received = true;
       } else if (state == It2MeNativeMessagingHost::HostStateToString(
                               kRequestedAccessCode)) {
@@ skipping 92 matching lines @@
   ASSERT_TRUE(MakePipe(&input_read_file, &input_write_file_));
   ASSERT_TRUE(MakePipe(&output_read_file_, &output_write_file));
 
   pipe_.reset(new NativeMessagingPipe());
 
   std::unique_ptr<extensions::NativeMessagingChannel> channel(
       new PipeMessagingChannel(std::move(input_read_file),
                                std::move(output_write_file)));
 
   // Creating a native messaging host with a mock It2MeHostFactory.
+  std::unique_ptr<ChromotingHostContext> context =
+      ChromotingHostContext::Create(host_task_runner_);
+  std::unique_ptr<PolicyWatcher> policy_watcher =
+      PolicyWatcher::CreateFromPolicyLoaderForTesting(
+          base::MakeUnique<policy::FakeAsyncPolicyLoader>(
+              base::ThreadTaskRunnerHandle::Get()));
   std::unique_ptr<extensions::NativeMessageHost> it2me_host(
       new It2MeNativeMessagingHost(
-          /*needs_elevation=*/false, fake_policy_service_.get(),
-          ChromotingHostContext::Create(host_task_runner_),
-          base::WrapUnique(new MockIt2MeHostFactory())));
+          /*needs_elevation=*/false, std::move(policy_watcher),
+          std::move(context), base::WrapUnique(new MockIt2MeHostFactory())));
   it2me_host->Start(pipe_.get());
 
   pipe_->Start(std::move(it2me_host), std::move(channel));
 
   // Notify the test that the host has finished starting up.
   test_message_loop_->task_runner()->PostTask(
       FROM_HERE, test_run_loop_->QuitClosure());
 }
 
 void It2MeNativeMessagingHostTest::ExitTest() {
@@ skipping 54 matching lines @@
   EXPECT_TRUE(response);
   std::string value;
   EXPECT_FALSE(response->GetString("id", &value));
 
   response = ReadMessageFromOutputPipe();
   EXPECT_TRUE(response);
   EXPECT_TRUE(response->GetString("id", &value));
   EXPECT_EQ("42", value);
 }
 
-TEST_F(It2MeNativeMessagingHostTest, Connect) {
+TEST_F(It2MeNativeMessagingHostTest, ConnectMultiple) {
   // A new It2MeHost instance is created for every it2me session. The native
   // messaging host, on the other hand, is long lived. This test verifies
   // multiple It2Me host startup and shutdowns.
   for (int i = 0; i < 3; ++i) {
     TestConnect();
   }
 }
 
 // Verify non-Dictionary requests are rejected.
 TEST_F(It2MeNativeMessagingHostTest, WrongFormat) {
   base::ListValue message;
   // No "error" response will be sent for non-Dictionary messages.
   TestBadRequest(message, false);
 }
 
 // Verify requests with no type are rejected.
 TEST_F(It2MeNativeMessagingHostTest, MissingType) {
   base::DictionaryValue message;
   TestBadRequest(message, true);
 }
 
 // Verify rejection if type is unrecognized.
 TEST_F(It2MeNativeMessagingHostTest, InvalidType) {
   base::DictionaryValue message;
   message.SetString("type", "xxx");
   TestBadRequest(message, true);
 }
 
 }  // namespace remoting