Fix IceTransportTest.TestBrokenTransport

remoting/protocol/ice_transport_unittest.cc

 // Copyright 2015 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/protocol/ice_transport.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/location.h"
@@ skipping 95 matching lines @@
   }
 
   void DeliverTransportInfo(scoped_ptr<IceTransport>* target_transport,
                             scoped_ptr<buzz::XmlElement> transport_info) {
     ASSERT_TRUE(target_transport);
     EXPECT_TRUE(
         (*target_transport)->ProcessTransportInfo(transport_info.get()));
   }
 
   void InitializeConnection() {
-    host_transport_.reset(
-        new IceTransport(TransportContext::ForTests(TransportRole::SERVER),
-                         &host_event_handler_));
+    jingle_glue::JingleThreadWrapper::EnsureForCurrentMessageLoop();
+
+    host_transport_.reset(new IceTransport(
+        new TransportContext(
+            nullptr, make_scoped_ptr(new ChromiumPortAllocatorFactory(nullptr)),
+            network_settings_, TransportRole::SERVER),
+        &host_event_handler_));
     if (!host_authenticator_) {
       host_authenticator_.reset(new FakeAuthenticator(
           FakeAuthenticator::HOST, 0, FakeAuthenticator::ACCEPT, true));
     }
 
-    client_transport_.reset(
-        new IceTransport(TransportContext::ForTests(TransportRole::CLIENT),
-                         &client_event_handler_));
+    client_transport_.reset(new IceTransport(
+        new TransportContext(
+            nullptr, make_scoped_ptr(new ChromiumPortAllocatorFactory(nullptr)),
+            network_settings_, TransportRole::CLIENT),
+        &client_event_handler_));
     if (!client_authenticator_) {
       client_authenticator_.reset(new FakeAuthenticator(
           FakeAuthenticator::CLIENT, 0, FakeAuthenticator::ACCEPT, true));
     }
 
     host_event_handler_.set_error_callback(base::Bind(
         &IceTransportTest::OnTransportError, base::Unretained(this)));
     client_event_handler_.set_error_callback(base::Bind(
         &IceTransportTest::OnTransportError, base::Unretained(this)));
 
@@ skipping 125 matching lines @@
   EXPECT_EQ(CHANNEL_CONNECTION_ERROR, error_);
 
   client_transport_->GetChannelFactory()->CancelChannelCreation(
       kChannelName);
 }
 
 // Verify that channels are never marked connected if connection cannot be
 // established.
 TEST_F(IceTransportTest, TestBrokenTransport) {
   // Allow only incoming connections on both ends, which effectively renders
-  // transport unusable.
+  // transport unusable. Also reduce connection timeout so the test finishes
+  // quickly.
   network_settings_ = NetworkSettings(NetworkSettings::NAT_TRAVERSAL_DISABLED);
+  network_settings_.ice_timeout = base::TimeDelta::FromSeconds(1);
+  network_settings_.ice_reconnect_attempts = 1;
 
   InitializeConnection();
 
   client_transport_->GetChannelFactory()->CreateChannel(
       kChannelName, base::Bind(&IceTransportTest::OnClientChannelCreated,
                                base::Unretained(this)));
   host_transport_->GetChannelFactory()->CreateChannel(
       kChannelName, base::Bind(&IceTransportTest::OnHostChannelCreated,
                                base::Unretained(this)));
 
-  message_loop_.RunUntilIdle();
+  // The RunLoop should quit in OnTransportError().
+  run_loop_.reset(new base::RunLoop());
+  run_loop_->Run();
 
   // Verify that neither of the two ends of the channel is connected.
   EXPECT_FALSE(client_message_pipe_);
   EXPECT_FALSE(host_message_pipe_);
+  EXPECT_EQ(CHANNEL_CONNECTION_ERROR, error_);
 
   client_transport_->GetChannelFactory()->CancelChannelCreation(
       kChannelName);
   host_transport_->GetChannelFactory()->CancelChannelCreation(
       kChannelName);
 }
 
 TEST_F(IceTransportTest, TestCancelChannelCreation) {
   InitializeConnection();
 
@@ skipping 24 matching lines @@
 
   MessagePipeConnectionTester tester(host_message_pipe_.get(),
                                      client_message_pipe_.get(), kMessageSize,
                                      kMessages);
   tester.RunAndCheckResults();
 }
 
 
 }  // namespace protocol
 }  // namespace remoting