Webapp share dialog is not closed when client end of the connection is closed

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 32 matching lines @@
 const char kResourceOnly[] = "/jid_resource";
 const char kMatchingDomain[] = "gmail.com";
 const char kMismatchedDomain1[] = "similar_to_gmail.com";
 const char kMismatchedDomain2[] = "gmail_at_the_beginning.com";
 const char kMismatchedDomain3[] = "not_even_close.com";
 
 }  // namespace
 
 class FakeIt2MeConfirmationDialog : public It2MeConfirmationDialog {
  public:
-  FakeIt2MeConfirmationDialog();
+  FakeIt2MeConfirmationDialog(const std::string& remote_user_email,
+                              DialogResult dialog_result);
   ~FakeIt2MeConfirmationDialog() override;
 
   // It2MeConfirmationDialog implementation.
   void Show(const std::string& remote_user_email,
             const ResultCallback& callback) override;
 
-  void set_dialog_result(DialogResult dialog_result) {
-    dialog_result_ = dialog_result;
-  }
+ private:
+  FakeIt2MeConfirmationDialog();
 
-  const std::string& get_remote_user_email() { return remote_user_email_; }
-
- private:
   std::string remote_user_email_;
   DialogResult dialog_result_ = DialogResult::OK;
 
   DISALLOW_COPY_AND_ASSIGN(FakeIt2MeConfirmationDialog);
 };
 
 FakeIt2MeConfirmationDialog::FakeIt2MeConfirmationDialog() {}
 
+FakeIt2MeConfirmationDialog::FakeIt2MeConfirmationDialog(
+    const std::string& remote_user_email,
+    DialogResult dialog_result)
+    : remote_user_email_(remote_user_email), dialog_result_(dialog_result) {}
+
 FakeIt2MeConfirmationDialog::~FakeIt2MeConfirmationDialog() {}
 
 void FakeIt2MeConfirmationDialog::Show(const std::string& remote_user_email,
                                        const ResultCallback& callback) {
-  remote_user_email_ = remote_user_email;
+  EXPECT_STREQ(remote_user_email_.c_str(), remote_user_email.c_str());
 
   base::ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE, base::Bind(callback, dialog_result_));
 }
 
+class FakeIt2MeDialogFactory : public It2MeConfirmationDialogFactory {
+ public:
+  FakeIt2MeDialogFactory();
+  ~FakeIt2MeDialogFactory() override;
+
+  std::unique_ptr<It2MeConfirmationDialog> Create() override;
+
+  void set_dialog_result(DialogResult dialog_result) {
+    dialog_result_ = dialog_result;
+  }
+
+  void set_remote_user_email(const std::string& remote_user_email) {
+    remote_user_email_ = remote_user_email;
+  }
+
+ private:
+  std::string remote_user_email_;
+  DialogResult dialog_result_ = DialogResult::OK;
+
+  DISALLOW_COPY_AND_ASSIGN(FakeIt2MeDialogFactory);
+};
+
+FakeIt2MeDialogFactory::FakeIt2MeDialogFactory()
+    : remote_user_email_(kTestClientUserName) {}
+
+FakeIt2MeDialogFactory::~FakeIt2MeDialogFactory() {}
+
+std::unique_ptr<It2MeConfirmationDialog> FakeIt2MeDialogFactory::Create() {
+  EXPECT_FALSE(remote_user_email_.empty());
+  return base::MakeUnique<FakeIt2MeConfirmationDialog>(remote_user_email_,
+                                                       dialog_result_);
+}
+
 class It2MeHostTest : public testing::Test, public It2MeHost::Observer {
  public:
   It2MeHostTest();
   ~It2MeHostTest() override;
 
   // testing::Test interface.
   void SetUp() override;
   void TearDown() override;
 
   void OnValidationComplete(const base::Closure& resume_callback,
@@ skipping 14 matching lines @@
 
   void SimulateClientConnection();
 
   void RunIncomingConnectionCallback(const std::string& remote_jid);
 
   void RunAcceptedConnectionCallback(const std::string& remote_jid);
 
   void DisconnectClient();
 
   ValidationResult validation_result_ = ValidationResult::SUCCESS;
-  std::string remote_user_email_;
 
   base::Closure state_change_callback_;
 
   It2MeHostState last_host_state_ = It2MeHostState::kDisconnected;
 
   // Used to set ConfirmationDialog behavior.
-  FakeIt2MeConfirmationDialog* dialog_ = nullptr;
+  FakeIt2MeDialogFactory* dialog_factory_ = nullptr;
 
  private:
   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_;
 
   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();
 
-  dialog_ = new FakeIt2MeConfirmationDialog();
+  std::unique_ptr<FakeIt2MeDialogFactory> dialog_factory(
+      new FakeIt2MeDialogFactory());
+  dialog_factory_ = dialog_factory.get();
   it2me_host_ =
-      new It2MeHost(std::move(host_context),
-                    /*policy_watcher=*/nullptr, base::WrapUnique(dialog_),
-                    weak_factory_.GetWeakPtr(),
+      new It2MeHost(std::move(host_context), /*policy_watcher=*/nullptr,
+                    std::move(dialog_factory), weak_factory_.GetWeakPtr(),
                     base::WrapUnique(new FakeSignalStrategy("fake_local_jid")),
                     "fake_user_name", "fake_bot_jid");
 }
 
 void It2MeHostTest::TearDown() {
   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;
-  remote_user_email_ = dialog_->get_remote_user_email();
 
   ui_task_runner_->PostTask(FROM_HERE, resume_callback);
 }
 
 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());
@@ skipping 170 matching lines @@
 }
 
 TEST_F(It2MeHostTest, ConnectionValidation_ConfirmationDialog_Accept) {
   SimulateClientConnection();
   RunIncomingConnectionCallback(kTestClientJid);
   ASSERT_EQ(ValidationResult::SUCCESS, validation_result_);
   ASSERT_EQ(It2MeHostState::kReceivedAccessCode, last_host_state_);
 
   RunAcceptedConnectionCallback(kTestClientJid);
   ASSERT_EQ(ValidationResult::SUCCESS, validation_result_);
-  ASSERT_STREQ(kTestClientUserName, remote_user_email_.c_str());
   ASSERT_EQ(It2MeHostState::kConnecting, last_host_state_);
 
   DisconnectClient();
   ASSERT_EQ(It2MeHostState::kDisconnected, last_host_state_);
 }
 
 TEST_F(It2MeHostTest, ConnectionValidation_ConfirmationDialog_Reject) {
-  dialog_->set_dialog_result(DialogResult::CANCEL);
+  dialog_factory_->set_dialog_result(DialogResult::CANCEL);
   SimulateClientConnection();
 
   RunIncomingConnectionCallback(kTestClientJid);
   ASSERT_EQ(ValidationResult::SUCCESS, validation_result_);
   ASSERT_EQ(It2MeHostState::kReceivedAccessCode, last_host_state_);
 
   RunAcceptedConnectionCallback(kTestClientJid);
   ASSERT_EQ(ValidationResult::ERROR_REJECTED_BY_USER, validation_result_);
   RunUntilStateChanged(It2MeHostState::kDisconnected);
   ASSERT_EQ(It2MeHostState::kDisconnected, last_host_state_);
-  ASSERT_STREQ(kTestClientUserName, remote_user_email_.c_str());
 }
 
 TEST_F(It2MeHostTest, MultipleConnectionsTriggerDisconnect) {
   SimulateClientConnection();
   RunIncomingConnectionCallback(kTestClientJid);
   ASSERT_EQ(ValidationResult::SUCCESS, validation_result_);
   ASSERT_EQ(It2MeHostState::kReceivedAccessCode, last_host_state_);
 
   RunAcceptedConnectionCallback(kTestClientJid);
   ASSERT_EQ(ValidationResult::SUCCESS, validation_result_);
   ASSERT_EQ(It2MeHostState::kConnecting, last_host_state_);
-  ASSERT_STREQ(kTestClientUserName, remote_user_email_.c_str());
 
   RunIncomingConnectionCallback(kTestClientJid2);
   ASSERT_EQ(ValidationResult::SUCCESS, validation_result_);
   ASSERT_EQ(It2MeHostState::kConnecting, last_host_state_);
 
   RunAcceptedConnectionCallback(kTestClientJid2);
   ASSERT_EQ(ValidationResult::ERROR_TOO_MANY_CONNECTIONS, validation_result_);
   RunUntilStateChanged(It2MeHostState::kDisconnected);
   ASSERT_EQ(It2MeHostState::kDisconnected, last_host_state_);
 }
 
 }  // namespace remoting