[Draft] Fix canceling pin prompt causes host overload

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/message_loop.h"
 #include "base/run_loop.h"
 #include "base/test/test_timeouts.h"
@@ skipping 87 matching lines @@
 
   // Helper method that handles OnIncomingSession().
   void SetHostSession(Session* session) {
     DCHECK(session);
     host_session_.reset(session);
     host_session_->SetEventHandler(&host_session_event_handler_);
 
     session->set_config(SessionConfig::ForTest());
   }
 
+  void DeleteSession() {
+    host_session_.reset();
+  }
+
   void OnClientChannelCreated(scoped_ptr<net::StreamSocket> socket) {
     client_channel_callback_.OnDone(socket.get());
     client_socket_ = socket.Pass();
   }
 
   void OnHostChannelCreated(scoped_ptr<net::StreamSocket> socket) {
     host_channel_callback_.OnDone(socket.get());
     host_socket_ = socket.Pass();
   }
 
  protected:
   virtual void SetUp() {
   }
 
   virtual void TearDown() {
     CloseSessions();
     CloseSessionManager();
     base::RunLoop().RunUntilIdle();
   }
 
   void CloseSessions() {
     host_socket_.reset();
     host_session_.reset();
     client_socket_.reset();
     client_session_.reset();
   }
 
-  void CreateSessionManagers(int auth_round_trips,
+  void CreateSessionManagers(int auth_round_trips, int messages_till_start,
                         FakeAuthenticator::Action auth_action) {
     host_signal_strategy_.reset(new FakeSignalStrategy(kHostJid));
     client_signal_strategy_.reset(new FakeSignalStrategy(kClientJid));
     FakeSignalStrategy::Connect(host_signal_strategy_.get(),
                                 client_signal_strategy_.get());
 
     EXPECT_CALL(host_server_listener_, OnSessionManagerReady())
         .Times(1);
 
     NetworkSettings network_settings(NetworkSettings::NAT_TRAVERSAL_OUTGOING);
 
     scoped_ptr<TransportFactory> host_transport(new LibjingleTransportFactory(
         NULL,
         ChromiumPortAllocator::Create(NULL, network_settings)
             .PassAs<cricket::HttpPortAllocatorBase>(),
         network_settings));
     host_server_.reset(new JingleSessionManager(host_transport.Pass()));
     host_server_->Init(host_signal_strategy_.get(), &host_server_listener_);
 
     scoped_ptr<AuthenticatorFactory> factory(
-        new FakeHostAuthenticatorFactory(auth_round_trips, auth_action, true));
+        new FakeHostAuthenticatorFactory(auth_round_trips,
+          messages_till_start, auth_action, true));
     host_server_->set_authenticator_factory(factory.Pass());
 
     EXPECT_CALL(client_server_listener_, OnSessionManagerReady())
         .Times(1);
     scoped_ptr<TransportFactory> client_transport(new LibjingleTransportFactory(
         NULL,
         ChromiumPortAllocator::Create(NULL, network_settings)
             .PassAs<cricket::HttpPortAllocatorBase>(),
         network_settings));
     client_server_.reset(
         new JingleSessionManager(client_transport.Pass()));
     client_server_->Init(client_signal_strategy_.get(),
                          &client_server_listener_);
   }
 
+  void CreateSessionManagers(int auth_round_trips,
+                             FakeAuthenticator::Action auth_action) {
+    CreateSessionManagers(auth_round_trips, 0, auth_action);
+  }
+
   void CloseSessionManager() {
     if (host_server_.get()) {
       host_server_->Close();
       host_server_.reset();
     }
     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) {
     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));
+      EXPECT_CALL(host_session_event_handler_,
+                  OnSessionStateChange(Session::AUTHENTICATING))
+          .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));
       }
     }
 
     {
       InSequence dummy;
 
       EXPECT_CALL(client_session_event_handler_,
                   OnSessionStateChange(Session::CONNECTED))
           .Times(AtMost(1));
+      EXPECT_CALL(client_session_event_handler_,
+                  OnSessionStateChange(Session::AUTHENTICATING))
+          .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_,
@@ skipping 138 matching lines @@
 
   ASSERT_NO_FATAL_FAILURE(CreateChannel());
 
   StreamConnectionTester tester(host_socket_.get(), client_socket_.get(),
                                 kMessageSize, kMessages);
   tester.Start();
   message_loop_->Run();
   tester.CheckResults();
 }
 
+TEST_F(JingleSessionTest, DeleteSessionOnIncomingConnection) {
+  CreateSessionManagers(3, FakeAuthenticator::ACCEPT);
+
+  EXPECT_CALL(host_server_listener_, OnIncomingSession(_, _))
+      .WillOnce(DoAll(
+          WithArg<0>(Invoke(this, &JingleSessionTest::SetHostSession)),
+          SetArgumentPointee<1>(protocol::SessionManager::ACCEPT)));
+
+  EXPECT_CALL(host_session_event_handler_,
+      OnSessionStateChange(Session::CONNECTED))
+      .Times(AtMost(1));
+
+  EXPECT_CALL(host_session_event_handler_,
+      OnSessionStateChange(Session::AUTHENTICATING))
+      .WillOnce(InvokeWithoutArgs(this, &JingleSessionTest::DeleteSession));
+
+  scoped_ptr<Authenticator> authenticator(new FakeAuthenticator(
+      FakeAuthenticator::CLIENT, 3, FakeAuthenticator::ACCEPT, true));
+
+  client_session_ = client_server_->Connect(
+      kHostJid, authenticator.Pass(),
+      CandidateSessionConfig::CreateDefault());
+
+  base::RunLoop().RunUntilIdle();
+}
+
+TEST_F(JingleSessionTest, DeleteSessionOnAuth) {
+  // Same as the previous test, but set messages_till_started to 2 in
+  // CreateSessionManagers so that the session will goes into the
+  // AUTHENTICATING state after two message exchanges.
+  CreateSessionManagers(3, 2, FakeAuthenticator::ACCEPT);
+
+  EXPECT_CALL(host_server_listener_, OnIncomingSession(_, _))
+      .WillOnce(DoAll(
+          WithArg<0>(Invoke(this, &JingleSessionTest::SetHostSession)),
+          SetArgumentPointee<1>(protocol::SessionManager::ACCEPT)));
+
+  EXPECT_CALL(host_session_event_handler_,
+      OnSessionStateChange(Session::CONNECTED))
+      .Times(AtMost(1));
+
+  EXPECT_CALL(host_session_event_handler_,
+      OnSessionStateChange(Session::AUTHENTICATING))
+      .WillOnce(InvokeWithoutArgs(this, &JingleSessionTest::DeleteSession));
+
+  scoped_ptr<Authenticator> authenticator(new FakeAuthenticator(
+      FakeAuthenticator::CLIENT, 3, FakeAuthenticator::ACCEPT, true));
+
+  client_session_ = client_server_->Connect(
+      kHostJid, authenticator.Pass(),
+      CandidateSessionConfig::CreateDefault());
+  base::RunLoop().RunUntilIdle();
+}
+
 // Verify that data can be sent over a multiplexed channel.
 TEST_F(JingleSessionTest, TestMuxStreamChannel) {
   CreateSessionManagers(1, FakeAuthenticator::ACCEPT);
   ASSERT_NO_FATAL_FAILURE(
       InitiateConnection(1, FakeAuthenticator::ACCEPT, false));
 
   client_session_->GetMultiplexedChannelFactory()->CreateStreamChannel(
       kChannelName, base::Bind(&JingleSessionTest::OnClientChannelCreated,
                                base::Unretained(this)));
   host_session_->GetMultiplexedChannelFactory()->CreateStreamChannel(
@@ skipping 54 matching lines @@
       .Times(AtMost(1));
   ExpectRouteChange(kChannelName);
 
   message_loop_->Run();
 
   EXPECT_TRUE(!host_socket_.get());
 }
 
 }  // namespace protocol
 }  // namespace remoting