Third Party authentication protocol.

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 38 matching lines @@
   base::FilePath cert_path = certs_dir.AppendASCII("unittest.selfsigned.der");
   ASSERT_TRUE(file_util::ReadFileToString(cert_path, &host_cert_));
 
   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_.reset(new KeyPair());
   key_pair_->LoadFromString(key_base64);
+  host_public_key_ = key_pair_->GetPublicKey();
 }
 
 void AuthenticatorTestBase::RunAuthExchange() {
-  do {
+  ContinueAuthExchange(false);
+}
+
+void AuthenticatorTestBase::ContinueAuthExchange(bool skip_client_to_host) {
+  while (client_->state() != Authenticator::ACCEPTED &&
+         client_->state() != Authenticator::REJECTED) {
     scoped_ptr<buzz::XmlElement> message;
 
-    // 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());
+    if (!skip_client_to_host) {
+      // 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());
 
-    ASSERT_EQ(Authenticator::WAITING_MESSAGE, host_->state());
-    host_->ProcessMessage(message.get());
-    ASSERT_NE(Authenticator::WAITING_MESSAGE, host_->state());
+      ASSERT_EQ(Authenticator::WAITING_MESSAGE, host_->state());
+      host_->ProcessMessage(message.get());
+      ASSERT_NE(Authenticator::WAITING_MESSAGE, host_->state());
+
+      if (host_->state() == Authenticator::WAITING_EXTERNAL) {
+        host_->PerformExternalAction(base::Bind(
+            &AuthenticatorTestBase::ContinueAuthExchange,
+            base::Unretained(this), true));
+        break;
+      }
+    } else {
+      skip_client_to_host = false;
+    }
 
     // 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);
+
+    if (client_->state() == Authenticator::WAITING_EXTERNAL) {
+      client_->PerformExternalAction(base::Bind(
+          &AuthenticatorTestBase::ContinueAuthExchange, base::Unretained(this),
+          false));
+      break;
+    }
+  }
 }
 
 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,
-                 base::Unretained(this)));
-
-  host_auth_->SecureAndAuthenticate(
-      host_fake_socket_.PassAs<net::StreamSocket>(),
-      base::Bind(&AuthenticatorTestBase::OnHostConnected,
-                 base::Unretained(this)));
-
   // Expect two callbacks to be called - the client callback and the host
   // callback.
   int callback_counter = 2;
 
   EXPECT_CALL(client_callback_, OnDone(net::OK))
       .WillOnce(QuitThreadOnCounter(&callback_counter));
   if (expected_fail) {
     EXPECT_CALL(host_callback_, OnDone(net::ERR_FAILED))
          .WillOnce(QuitThreadOnCounter(&callback_counter));
   } else {
     EXPECT_CALL(host_callback_, OnDone(net::OK))
         .WillOnce(QuitThreadOnCounter(&callback_counter));
   }
 
+  client_auth_->SecureAndAuthenticate(
+      client_fake_socket_.PassAs<net::StreamSocket>(),
+      base::Bind(&AuthenticatorTestBase::OnClientConnected,
+                 base::Unretained(this)));
+
+  host_auth_->SecureAndAuthenticate(
+      host_fake_socket_.PassAs<net::StreamSocket>(),
+      base::Bind(&AuthenticatorTestBase::OnHostConnected,
+                 base::Unretained(this)));
+
   // Ensure that .Run() does not run unbounded if the callbacks are never
   // called.
   base::Timer shutdown_timer(false, false);
   shutdown_timer.Start(FROM_HERE, TestTimeouts::action_timeout(),
                        MessageLoop::QuitClosure());
   message_loop_.Run();
   shutdown_timer.Stop();
 
   testing::Mock::VerifyAndClearExpectations(&client_callback_);
   testing::Mock::VerifyAndClearExpectations(&host_callback_);
@@ skipping 13 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