Fix flakiness of the TestFailedChannelAuth unittest.

remoting/protocol/jingle_session_unittest.cc

 // Copyright (c) 2012 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/jingle_session.h"
 
 #include "base/bind.h"
 #include "base/message_loop.h"
 #include "base/time.h"
 #include "base/test/test_timeouts.h"
@@ skipping 34 matching lines @@
 // Send 100 messages 1024 bytes each. UDP messages are sent with 10ms delay
 // between messages (about 1 second for 100 messages).
 const int kMessageSize = 1024;
 const int kMessages = 100;
 const char kChannelName[] = "test_channel";
 
 void QuitCurrentThread() {
   MessageLoop::current()->PostTask(FROM_HERE, MessageLoop::QuitClosure());
 }
 
+ACTION(QuitThread) {
+  QuitCurrentThread();
+}
+
 ACTION_P(QuitThreadOnCounter, counter) {
   --(*counter);
   EXPECT_GE(*counter, 0);
   if (*counter == 0)
     QuitCurrentThread();
 }
 
 class MockSessionManagerListener : public SessionManager::Listener {
  public:
   MOCK_METHOD0(OnSessionManagerReady, void());
@@ skipping 158 matching lines @@
 
     client_session_ = client_server_->Connect(
         kHostJid, authenticator.Pass(),
         CandidateSessionConfig::CreateDefault(),
         base::Bind(&MockSessionCallback::OnStateChange,
                    base::Unretained(&client_connection_callback_)));
 
     message_loop_->RunAllPending();
   }
 
-  void CreateChannel(bool expect_fail) {
+  void CreateChannel() {
     client_session_->CreateStreamChannel(kChannelName, base::Bind(
         &JingleSessionTest::OnClientChannelCreated, base::Unretained(this)));
     host_session_->CreateStreamChannel(kChannelName, base::Bind(
         &JingleSessionTest::OnHostChannelCreated, base::Unretained(this)));
 
     int counter = 2;
     EXPECT_CALL(client_channel_callback_, OnDone(_))
         .WillOnce(QuitThreadOnCounter(&counter));
     EXPECT_CALL(host_channel_callback_, OnDone(_))
         .WillOnce(QuitThreadOnCounter(&counter));
     message_loop_->Run();
 
-    if (expect_fail) {
-      // At least one socket should fail to connect.
-      EXPECT_TRUE((!client_socket_.get()) || (!host_socket_.get()));
-    } else {
-      EXPECT_TRUE(client_socket_.get());
-      EXPECT_TRUE(host_socket_.get());
-    }
+    EXPECT_TRUE(client_socket_.get());
+    EXPECT_TRUE(host_socket_.get());
   }
 
   scoped_ptr<JingleThreadMessageLoop> message_loop_;
 
   scoped_ptr<FakeSignalStrategy> host_signal_strategy_;
   scoped_ptr<FakeSignalStrategy> client_signal_strategy_;
 
   scoped_ptr<JingleSessionManager> host_server_;
   MockSessionManagerListener host_server_listener_;
   scoped_ptr<JingleSessionManager> client_server_;
@@ skipping 81 matching lines @@
   CreateSessionManagers(3, FakeAuthenticator::REJECT);
   InitiateConnection(3, FakeAuthenticator::ACCEPT, true);
 }
 
 // Verify that data can be sent over stream channel.
 TEST_F(JingleSessionTest, TestStreamChannel) {
   CreateSessionManagers(1, FakeAuthenticator::ACCEPT);
   ASSERT_NO_FATAL_FAILURE(
       InitiateConnection(1, FakeAuthenticator::ACCEPT, false));
 
-  ASSERT_NO_FATAL_FAILURE(CreateChannel(false));
+  ASSERT_NO_FATAL_FAILURE(CreateChannel());
 
   StreamConnectionTester tester(host_socket_.get(), client_socket_.get(),
                                 kMessageSize, kMessages);
   tester.Start();
   message_loop_->Run();
   tester.CheckResults();
 }
 
 // Verify that we can connect channels with multistep auth.
 TEST_F(JingleSessionTest, TestMultistepAuthStreamChannel) {
   CreateSessionManagers(3, FakeAuthenticator::ACCEPT);
   ASSERT_NO_FATAL_FAILURE(
       InitiateConnection(3, FakeAuthenticator::ACCEPT, false));
 
-  ASSERT_NO_FATAL_FAILURE(CreateChannel(false));
+  ASSERT_NO_FATAL_FAILURE(CreateChannel());
 
   StreamConnectionTester tester(host_socket_.get(), client_socket_.get(),
                                 kMessageSize, kMessages);
   tester.Start();
   message_loop_->Run();
   tester.CheckResults();
 }
 
 // Verify that we shutdown properly when channel authentication fails.
 TEST_F(JingleSessionTest, TestFailedChannelAuth) {
-  CreateSessionManagers(1, FakeAuthenticator::ACCEPT);
+  CreateSessionManagers(1, FakeAuthenticator::REJECT_CHANNEL);
   ASSERT_NO_FATAL_FAILURE(
-      InitiateConnection(1, FakeAuthenticator::REJECT_CHANNEL, false));
+      InitiateConnection(1, FakeAuthenticator::ACCEPT, false));
 
-  ASSERT_NO_FATAL_FAILURE(CreateChannel(true));
+  client_session_->CreateStreamChannel(kChannelName, base::Bind(
+      &JingleSessionTest::OnClientChannelCreated, base::Unretained(this)));
+  host_session_->CreateStreamChannel(kChannelName, base::Bind(
+      &JingleSessionTest::OnHostChannelCreated, base::Unretained(this)));
+
+  // Terminate the message loop when we get rejection notification
+  // from the host.
+  EXPECT_CALL(host_channel_callback_, OnDone(NULL))
+      .WillOnce(QuitThread());
+  EXPECT_CALL(client_channel_callback_, OnDone(_))
+      .Times(AtMost(1));
+
+  message_loop_->Run();
+
+  EXPECT_TRUE(!host_socket_.get());
 }
 
 }  // namespace protocol
 }  // namespace remoting