Update Windows It2Me to allow remote users to interact with elevated windows

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/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 32 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);
 }
 
-}  // namespace
+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,
                 const XmppSignalStrategy::XmppServerConfig& xmpp_server_config,
                 const std::string& directory_bot_jid)
       : It2MeHost(std::move(context),
                   std::move(policy_watcher),
@@ skipping 64 matching lines @@
   if (!host_context()->network_task_runner()->BelongsToCurrentThread()) {
     host_context()->network_task_runner()->PostTask(
         FROM_HERE, base::Bind(&It2MeHost::SetStateForTesting, this, state, ""));
   } else {
     SetStateForTesting(state, "");
   }
 }
 
 class MockIt2MeHostFactory : public It2MeHostFactory {
  public:
-  MockIt2MeHostFactory() : It2MeHostFactory() {}
+  MockIt2MeHostFactory();
+  ~MockIt2MeHostFactory() override;
+
   scoped_refptr<It2MeHost> CreateIt2MeHost(
       std::unique_ptr<ChromotingHostContext> context,
+      policy::PolicyService* policy_service,
       base::WeakPtr<It2MeHost::Observer> observer,
       const XmppSignalStrategy::XmppServerConfig& xmpp_server_config,
-      const std::string& directory_bot_jid) override {
-    return new MockIt2MeHost(std::move(context),
-                             /*confirmation_dialog_factory=*/nullptr, observer,
-                             xmpp_server_config, directory_bot_jid);
-  }
+      const std::string& directory_bot_jid) override;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(MockIt2MeHostFactory);
-};  // 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,
+    const XmppSignalStrategy::XmppServerConfig& xmpp_server_config,
+    const std::string& directory_bot_jid) {
+  return new MockIt2MeHost(std::move(context),
+                           /*policy_watcher=*/nullptr, observer,
+                           xmpp_server_config, directory_bot_jid);
+}
+
+}  // namespace
 
 class It2MeNativeMessagingHostTest : public testing::Test {
  public:
   It2MeNativeMessagingHostTest() {}
   ~It2MeNativeMessagingHostTest() override {}
 
   void SetUp() override;
   void TearDown() override;
 
  protected:
@@ skipping 29 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 207 matching lines @@
 
   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<extensions::NativeMessageHost> it2me_host(
       new It2MeNativeMessagingHost(
+          /*needs_elevation=*/false, fake_policy_service_.get(),
           ChromotingHostContext::Create(host_task_runner_),
           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());
 }
@@ skipping 85 matching lines @@
 }
 
 // Verify rejection if type is unrecognized.
 TEST_F(It2MeNativeMessagingHostTest, InvalidType) {
   base::DictionaryValue message;
   message.SetString("type", "xxx");
   TestBadRequest(message, true);
 }
 
 }  // namespace remoting