[Chromoting] Fix unit test warnings introduced in r146455.

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"
 #include "net/socket/socket.h"
 #include "net/socket/stream_socket.h"
 #include "remoting/base/constants.h"
 #include "remoting/protocol/authenticator.h"
 #include "remoting/protocol/channel_authenticator.h"
 #include "remoting/protocol/connection_tester.h"
 #include "remoting/protocol/fake_authenticator.h"
 #include "remoting/protocol/jingle_session_manager.h"
 #include "remoting/protocol/libjingle_transport_factory.h"
 #include "remoting/jingle_glue/jingle_thread.h"
 #include "remoting/jingle_glue/fake_signal_strategy.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using testing::_;
+using testing::AtLeast;
 using testing::AtMost;
 using testing::DeleteArg;
 using testing::DoAll;
 using testing::InSequence;
 using testing::Invoke;
 using testing::InvokeWithoutArgs;
 using testing::Return;
 using testing::SaveArg;
 using testing::SetArgumentPointee;
 using testing::WithArg;
@@ skipping 127 matching lines @@
     if (client_server_.get()) {
       client_server_->Close();
       client_server_.reset();
     }
     host_signal_strategy_.reset();
     client_signal_strategy_.reset();
   }
 
   void InitiateConnection(int auth_round_trips,
                           FakeAuthenticator::Action auth_action,
-                          bool expect_fail) {
+                          bool expect_fail, bool expect_session_route_change) {
     EXPECT_CALL(host_server_listener_, OnIncomingSession(_, _))
         .WillOnce(DoAll(
             WithArg<0>(Invoke(this, &JingleSessionTest::SetHostSession)),
             SetArgumentPointee<1>(protocol::SessionManager::ACCEPT)));
 
     {
       InSequence dummy;
 
       EXPECT_CALL(host_session_event_handler_,
                   OnSessionStateChange(Session::CONNECTED))
           .Times(AtMost(1));
       if (expect_fail) {
         EXPECT_CALL(host_session_event_handler_,
                     OnSessionStateChange(Session::FAILED))
             .Times(1);
       } else {
         EXPECT_CALL(host_session_event_handler_,
                     OnSessionStateChange(Session::AUTHENTICATED))
             .Times(1);
         // Expect that the connection will be closed eventually.
         EXPECT_CALL(host_session_event_handler_,
                     OnSessionStateChange(Session::CLOSED))
             .Times(AtMost(1));
       }
     }
+    if (expect_session_route_change) {

[Sergey Ulanov, 2012/07/23 22:05:37]

It's better to put this in CreateChannel() as we expect this callback only when
we create at least one channel.
And you probably need to copy them in TestFailedChannelAuth as it creates a
channel but doesn't call CreateChannel()

[simonmorris, 2012/07/23 22:21:25]

Done.

+      EXPECT_CALL(host_session_event_handler_,
+                  OnSessionRouteChange(kChannelName, _))
+          .Times(AtLeast(1));
+    }
 
     {
       InSequence dummy;
 
       EXPECT_CALL(client_session_event_handler_,
                   OnSessionStateChange(Session::CONNECTED))
           .Times(AtMost(1));
       if (expect_fail) {
         EXPECT_CALL(client_session_event_handler_,
                     OnSessionStateChange(Session::FAILED))
             .Times(1);
       } else {
         EXPECT_CALL(client_session_event_handler_,
                     OnSessionStateChange(Session::AUTHENTICATED))
             .Times(1);
         // Expect that the connection will be closed eventually.
         EXPECT_CALL(client_session_event_handler_,
                     OnSessionStateChange(Session::CLOSED))
             .Times(AtMost(1));
       }
     }
+    if (expect_session_route_change) {
+      EXPECT_CALL(client_session_event_handler_,
+                  OnSessionRouteChange(kChannelName, _))
+          .Times(AtLeast(1));
+    }
 
     scoped_ptr<Authenticator> authenticator(new FakeAuthenticator(
         FakeAuthenticator::CLIENT, auth_round_trips, auth_action, true));
 
     client_session_ = client_server_->Connect(
         kHostJid, authenticator.Pass(),
         CandidateSessionConfig::CreateDefault());
     client_session_->SetEventHandler(&client_session_event_handler_);
 
     message_loop_->RunAllPending();
@@ skipping 66 matching lines @@
   client_session_ = client_server_->Connect(
       kHostJid, authenticator.Pass(), CandidateSessionConfig::CreateDefault());
   client_session_->SetEventHandler(&client_session_event_handler_);
 
   message_loop_->RunAllPending();
 }
 
 // Verify that we can connect two endpoints with single-step authentication.
 TEST_F(JingleSessionTest, Connect) {
   CreateSessionManagers(1, FakeAuthenticator::ACCEPT);
-  InitiateConnection(1, FakeAuthenticator::ACCEPT, false);
+  InitiateConnection(1, FakeAuthenticator::ACCEPT, false, false);
 
   // Verify that the client specified correct initiator value.
   ASSERT_GT(host_signal_strategy_->received_messages().size(), 0U);
   const buzz::XmlElement* initiate_xml =
       host_signal_strategy_->received_messages().front();
   const buzz::XmlElement* jingle_element =
       initiate_xml->FirstNamed(buzz::QName(kJingleNamespace, "jingle"));
   ASSERT_TRUE(jingle_element);
   ASSERT_EQ(kClientJid,
             jingle_element->Attr(buzz::QName("", "initiator")));
 }
 
 // Verify that we can connect two endpoints with multi-step authentication.
 TEST_F(JingleSessionTest, ConnectWithMultistep) {
   CreateSessionManagers(3, FakeAuthenticator::ACCEPT);
-  InitiateConnection(3, FakeAuthenticator::ACCEPT, false);
+  InitiateConnection(3, FakeAuthenticator::ACCEPT, false, false);
 }
 
 // Verify that connection is terminated when single-step auth fails.
 TEST_F(JingleSessionTest, ConnectWithBadAuth) {
   CreateSessionManagers(1, FakeAuthenticator::REJECT);
-  InitiateConnection(1, FakeAuthenticator::ACCEPT, true);
+  InitiateConnection(1, FakeAuthenticator::ACCEPT, true, false);
 }
 
 // Verify that connection is terminated when multi-step auth fails.
 TEST_F(JingleSessionTest, ConnectWithBadMultistepAuth) {
   CreateSessionManagers(3, FakeAuthenticator::REJECT);
-  InitiateConnection(3, FakeAuthenticator::ACCEPT, true);
+  InitiateConnection(3, FakeAuthenticator::ACCEPT, true, false);
 }
 
 // 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));
+      InitiateConnection(1, FakeAuthenticator::ACCEPT, false, true));
 
   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));
+      InitiateConnection(3, FakeAuthenticator::ACCEPT, false, true));
 
   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::REJECT_CHANNEL);
   ASSERT_NO_FATAL_FAILURE(
-      InitiateConnection(1, FakeAuthenticator::ACCEPT, false));
+      InitiateConnection(1, FakeAuthenticator::ACCEPT, false, 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