[Draft] Fix canceling pin prompt causes host overload

remoting/protocol/authenticator_test_base.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/authenticator_test_base.h"
 
 #include "base/base64.h"
 #include "base/file_util.h"
 #include "base/files/file_path.h"
 #include "base/path_service.h"
@@ skipping 42 matching lines @@
   std::string key_string;
   ASSERT_TRUE(base::ReadFileToString(key_path, &key_string));
   std::string key_base64;
   base::Base64Encode(key_string, &key_base64);
   key_pair_ = RsaKeyPair::FromString(key_base64);
   ASSERT_TRUE(key_pair_.get());
   host_public_key_ = key_pair_->GetPublicKey();
 }
 
 void AuthenticatorTestBase::RunAuthExchange() {
-  ContinueAuthExchangeWith(client_.get(), host_.get());
+  ContinueAuthExchangeWith(client_.get(),
+                           host_.get(),
+                           client_->started(),
+                           host_->started());
 }
 
 void AuthenticatorTestBase::RunHostInitiatedAuthExchange() {
-  ContinueAuthExchangeWith(host_.get(), client_.get());
+  ContinueAuthExchangeWith(host_.get(),
+                           client_.get(),
+                           host_->started(),
+                           client_->started());
 }
 
 // static
+// This function sends a message from the sender and receiver and recursively
+// calls itself to the send the next message from the receiver to the sender
+// untils the authentication completes.
 void AuthenticatorTestBase::ContinueAuthExchangeWith(Authenticator* sender,
-                                                     Authenticator* receiver) {
+                                                     Authenticator* receiver,
+                                                     bool sender_started,
+                                                     bool receiver_started) {
   scoped_ptr<buzz::XmlElement> message;
   ASSERT_NE(Authenticator::WAITING_MESSAGE, sender->state());
   if (sender->state() == Authenticator::ACCEPTED ||
       sender->state() == Authenticator::REJECTED)
     return;
-  // Pass message from client to host.
+
+  // Verify that once the started flag for either party is set to true,
+  // it should always stay true.
+  if (receiver_started) {
+    ASSERT_TRUE(receiver->started());
+  }
+
+  if (sender_started) {
+    ASSERT_TRUE(sender->started());
+  }
+
   ASSERT_EQ(Authenticator::MESSAGE_READY, sender->state());
   message = sender->GetNextMessage();
   ASSERT_TRUE(message.get());
   ASSERT_NE(Authenticator::MESSAGE_READY, sender->state());
 
   ASSERT_EQ(Authenticator::WAITING_MESSAGE, receiver->state());
   receiver->ProcessMessage(message.get(), base::Bind(
       &AuthenticatorTestBase::ContinueAuthExchangeWith,
-      base::Unretained(receiver), base::Unretained(sender)));
+      base::Unretained(receiver), base::Unretained(sender),
+      receiver->started(), sender->started()));
 }
 
 void AuthenticatorTestBase::RunChannelAuth(bool expected_fail) {
   client_fake_socket_.reset(new FakeSocket());
   host_fake_socket_.reset(new FakeSocket());
   client_fake_socket_->PairWith(host_fake_socket_.get());
 
   client_auth_->SecureAndAuthenticate(
       client_fake_socket_.PassAs<net::StreamSocket>(),
       base::Bind(&AuthenticatorTestBase::OnClientConnected,
@@ skipping 45 matching lines @@
 
 void AuthenticatorTestBase::OnClientConnected(
     net::Error error,
     scoped_ptr<net::StreamSocket> socket) {
   client_callback_.OnDone(error);
   client_socket_ = socket.Pass();
 }
 
 }  // namespace protocol
 }  // namespace remoting