Add support for multiple allowed domains

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>
 
@@ skipping 75 matching lines @@
 
   // testing::Test interface.
   void SetUp() override;
   void TearDown() override;
 
   void OnValidationComplete(const base::Closure& resume_callback,
                             ValidationResult validation_result);
 
  protected:
   void SetClientDomainPolicy(const std::string& policy_value);
+  void SetClientDomainListPolicy(const std::vector<std::string>& policy_value);
 
   void RunValidationCallback(const std::string& remote_jid);
 
   ValidationResult validation_result_ = ValidationResult::SUCCESS;
   std::string remote_user_email_;
 
   // Used to set ConfirmationDialog behavior.
   FakeIt2MeConfirmationDialog* dialog_ = nullptr;
 
  private:
@@ skipping 44 matching lines @@
 
 void It2MeHostTest::SetClientDomainPolicy(const std::string& policy_value) {
   std::unique_ptr<base::DictionaryValue> policies(new base::DictionaryValue());
   policies->SetString(policy::key::kRemoteAccessHostClientDomain, policy_value);
 
   base::RunLoop run_loop;
   it2me_host_->SetPolicyForTesting(std::move(policies), run_loop.QuitClosure());
   run_loop.Run();
 }
 
+void It2MeHostTest::SetClientDomainListPolicy(
+    const std::vector<std::string> &policy_value) {
+  auto policies = base::MakeUnique<base::DictionaryValue>();
+  auto domains = base::MakeUnique<base::ListValue>();
+  domains->AppendStrings(policy_value);
+  policies->Set(policy::key::kRemoteAccessHostClientDomainList,
+                std::move(domains));
+
+  base::RunLoop run_loop;
+  it2me_host_->SetPolicyForTesting(std::move(policies), run_loop.QuitClosure());
+  run_loop.Run();
+}
+
 void It2MeHostTest::RunValidationCallback(const std::string& remote_jid) {
   base::RunLoop run_loop;
 
   network_task_runner_->PostTask(
       FROM_HERE, base::Bind(&It2MeHost::SetStateForTesting, it2me_host_.get(),
                             It2MeHostState::kStarting, std::string()));
 
   network_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&It2MeHost::SetStateForTesting, it2me_host_.get(),
@@ skipping 65 matching lines @@
   RunValidationCallback(kTestClientJid);
   ASSERT_EQ(ValidationResult::ERROR_INVALID_ACCOUNT, validation_result_);
 }
 
 TEST_F(It2MeHostTest, ConnectionValidation_WrongClientDomain_MatchEnd) {
   SetClientDomainPolicy(kMismatchedDomain1);
   RunValidationCallback(kTestClientJid);
   ASSERT_EQ(ValidationResult::ERROR_INVALID_ACCOUNT, validation_result_);
 }
 
+TEST_F(It2MeHostTest, ConnectionValidation_ClientDomainListPolicy_Match) {
+  SetClientDomainListPolicy({kMismatchedDomain1, kMismatchedDomain2,
+                             kMatchingDomain, kMismatchedDomain3});
+  RunValidationCallback(kTestClientJid);
+  ASSERT_EQ(ValidationResult::SUCCESS, validation_result_);
+}
+
+TEST_F(It2MeHostTest, ConnectionValidation_ClientDomainListPolicy_NoMatch) {
+  SetClientDomainListPolicy({kMismatchedDomain1, kMismatchedDomain2,
+                             kMismatchedDomain3});
+  RunValidationCallback(kTestClientJid);
+  ASSERT_EQ(ValidationResult::ERROR_INVALID_ACCOUNT, validation_result_);
+}
+
+TEST_F(It2MeHostTest,
+       ConnectionValidation_ClientDomainListPolicy_InvalidUsername) {
+  SetClientDomainListPolicy({kMismatchedDomain1, kMismatchedDomain2,
+                             kMatchingDomain, kMismatchedDomain3});
+  RunValidationCallback(kTestClientJidWithSlash);
+  ASSERT_EQ(ValidationResult::ERROR_INVALID_ACCOUNT, validation_result_);
+}
+
+TEST_F(It2MeHostTest, ConnectionValidation_ClientDomainListPolicy_NoJid) {
+  SetClientDomainListPolicy({kMismatchedDomain1, kMismatchedDomain2,
+                             kMatchingDomain, kMismatchedDomain3});
+  RunValidationCallback(kTestClientUsernameNoJid);
+  ASSERT_EQ(ValidationResult::ERROR_INVALID_ACCOUNT, validation_result_);
+}
+
+TEST_F(It2MeHostTest, ConnectionValidation_ClientDomainPolicy_List_Match) {
+  SetClientDomainPolicy(kMatchingDomain);
+  SetClientDomainListPolicy({kMismatchedDomain1, kMismatchedDomain2,
+                             kMatchingDomain, kMismatchedDomain3});
+  RunValidationCallback(kTestClientJid);
+  ASSERT_EQ(ValidationResult::SUCCESS, validation_result_);
+}
+
+TEST_F(It2MeHostTest, ConnectionValidation_ClientDomainPolicy_List_NoMatch1) {
+  SetClientDomainPolicy(kMatchingDomain);
+  SetClientDomainListPolicy({kMismatchedDomain1, kMismatchedDomain2,
+                             kMismatchedDomain3});
+  RunValidationCallback(kTestClientJid);
+  ASSERT_EQ(ValidationResult::ERROR_INVALID_ACCOUNT, validation_result_);
+}
+
+TEST_F(It2MeHostTest, ConnectionValidation_ClientDomainPolicy_List_NoMatch2) {
+  SetClientDomainPolicy(kMismatchedDomain1);
+  SetClientDomainListPolicy({kMismatchedDomain1, kMismatchedDomain2,
+                             kMatchingDomain, kMismatchedDomain3});
+  RunValidationCallback(kTestClientJid);
+  ASSERT_EQ(ValidationResult::ERROR_INVALID_ACCOUNT, validation_result_);
+}
+
 TEST_F(It2MeHostTest, ConnectionValidation_ConfirmationDialog_Accept) {
   RunValidationCallback(kTestClientJid);
   ASSERT_EQ(ValidationResult::SUCCESS, validation_result_);
   ASSERT_STREQ(kTestClientUserName, remote_user_email_.c_str());
 }
 
 TEST_F(It2MeHostTest, ConnectionValidation_ConfirmationDialog_Reject) {
   dialog_->set_dialog_result(DialogResult::CANCEL);
   RunValidationCallback(kTestClientJid);
   ASSERT_EQ(ValidationResult::ERROR_REJECTED_BY_USER, validation_result_);
   ASSERT_STREQ(kTestClientUserName, remote_user_email_.c_str());
 }
 
 }  // namespace remoting