Refactor of Authenticator to allow it to ProcessMessage asynchronously and then call a callback

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_path.h"
 #include "base/file_util.h"
 #include "base/path_service.h"
@@ skipping 41 matching lines @@
   base::FilePath key_path = certs_dir.AppendASCII("unittest.key.bin");
   std::string key_string;
   ASSERT_TRUE(file_util::ReadFileToString(key_path, &key_string));
   std::string key_base64;
   base::Base64Encode(key_string, &key_base64);
   key_pair_ = new RsaKeyPair();
   key_pair_->LoadFromString(key_base64);
 }
 
 void AuthenticatorTestBase::RunAuthExchange() {
-  do {
-    scoped_ptr<buzz::XmlElement> message;
+  RunAuthExchangeStep(client_.get(), host_.get());
+}
 
-    // Pass message from client to host.
-    ASSERT_EQ(Authenticator::MESSAGE_READY, client_->state());
-    message = client_->GetNextMessage();
-    ASSERT_TRUE(message.get());
-    ASSERT_NE(Authenticator::MESSAGE_READY, client_->state());
+void AuthenticatorTestBase::RunAuthExchangeStep(Authenticator* sender,
+                                                Authenticator* receiver) {
+  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.
+  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, host_->state());
-    host_->ProcessMessage(message.get());
-    ASSERT_NE(Authenticator::WAITING_MESSAGE, host_->state());
-
-    // Are we done yet?
-    if (host_->state() == Authenticator::ACCEPTED ||
-        host_->state() == Authenticator::REJECTED) {
-      break;
-    }
-
-    // Pass message from host to client.
-    ASSERT_EQ(Authenticator::MESSAGE_READY, host_->state());
-    message = host_->GetNextMessage();
-    ASSERT_TRUE(message.get());
-    ASSERT_NE(Authenticator::MESSAGE_READY, host_->state());
-
-    ASSERT_EQ(Authenticator::WAITING_MESSAGE, client_->state());
-    client_->ProcessMessage(message.get());
-    ASSERT_NE(Authenticator::WAITING_MESSAGE, client_->state());
-  } while (client_->state() != Authenticator::ACCEPTED &&
-           client_->state() != Authenticator::REJECTED);
+  ASSERT_EQ(Authenticator::WAITING_MESSAGE, receiver->state());
+  receiver->ProcessMessage(base::Bind(
+      &AuthenticatorTestBase::RunAuthExchangeStep,
+      base::Unretained(this), base::Unretained(receiver),
+      base::Unretained(sender)), message.get());
 }
 
 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 44 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