Report signling errors for register-support-host requests.

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 164 matching lines @@
 
   std::unique_ptr<base::DictionaryValue> policies_;
 
   scoped_refptr<It2MeHost> it2me_host_;
 
  private:
   void StartupHostStateHelper(const base::Closure& quit_closure);
 
   std::unique_ptr<base::MessageLoop> message_loop_;
   std::unique_ptr<base::RunLoop> run_loop_;
+  std::unique_ptr<FakeSignalStrategy> fake_bot_signal_strategy_;
 
   std::unique_ptr<ChromotingHostContext> host_context_;
   scoped_refptr<AutoThreadTaskRunner> network_task_runner_;
   scoped_refptr<AutoThreadTaskRunner> ui_task_runner_;
 
   base::WeakPtrFactory<It2MeHostTest> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(It2MeHostTest);
 };
 
 It2MeHostTest::It2MeHostTest() : weak_factory_(this) {}
 It2MeHostTest::~It2MeHostTest() {}
 
 void It2MeHostTest::SetUp() {
 #if defined(OS_LINUX)
   // Need to prime the host OS version value for linux to prevent IO on the
   // network thread. base::GetLinuxDistro() caches the result.
   base::GetLinuxDistro();
 #endif
   message_loop_.reset(new base::MessageLoop());
   run_loop_.reset(new base::RunLoop());
 
   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();
+  fake_bot_signal_strategy_.reset(
+      new FakeSignalStrategy(SignalingAddress("fake_bot_jid")));
 }
 
 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;
   host_context_.reset();
   it2me_host_ = nullptr;
@@ skipping 40 matching lines @@
 
   std::unique_ptr<FakeIt2MeDialogFactory> dialog_factory(
       new FakeIt2MeDialogFactory());
   dialog_factory_ = dialog_factory.get();
 
   protocol::IceConfig ice_config;
   ice_config.stun_servers.push_back(rtc::SocketAddress(kTestStunServer, 100));
   ice_config.expiration_time =
       base::Time::Now() + base::TimeDelta::FromHours(1);
 
+  auto fake_signal_strategy =
+      base::MakeUnique<FakeSignalStrategy>(SignalingAddress("fake_local_jid"));
+  fake_bot_signal_strategy_->ConnectTo(fake_signal_strategy.get());
+
   it2me_host_ = new It2MeHost();
   it2me_host_->Connect(host_context_->Copy(),
                        base::MakeUnique<base::DictionaryValue>(*policies_),
                        std::move(dialog_factory), weak_factory_.GetWeakPtr(),
-                       base::WrapUnique(new FakeSignalStrategy(
-                           SignalingAddress("fake_local_jid"))),
-                       kTestUserName, "fake_bot_jid", ice_config);
+                       std::move(fake_signal_strategy), kTestUserName,
+                       "fake_bot_jid", ice_config);
 
   base::RunLoop run_loop;
   state_change_callback_ =
       base::Bind(&It2MeHostTest::StartupHostStateHelper, base::Unretained(this),
                  run_loop.QuitClosure());
   run_loop.Run();
 }
 
 void It2MeHostTest::RunUntilStateChanged(It2MeHostState expected_state) {
   if (last_host_state_ == expected_state) {
@@ skipping 303 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