Make the mapping from client id -> secret asynchronous.

remoting/protocol/negotiating_authenticator_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 "base/bind.h"
 #include "net/base/net_errors.h"
 #include "remoting/base/rsa_key_pair.h"
 #include "remoting/protocol/authenticator_test_base.h"
 #include "remoting/protocol/channel_authenticator.h"
 #include "remoting/protocol/connection_tester.h"
 #include "remoting/protocol/negotiating_authenticator_base.h"
 #include "remoting/protocol/negotiating_client_authenticator.h"
 #include "remoting/protocol/negotiating_host_authenticator.h"
 #include "remoting/protocol/pairing_registry.h"
+#include "remoting/protocol/protocol_mock_objects.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/libjingle/source/talk/xmllite/xmlelement.h"
 
 using testing::_;
 using testing::DeleteArg;
 using testing::SaveArg;
 
 namespace remoting {
 namespace protocol {
@@ skipping 22 matching lines @@
   virtual ~NegotiatingAuthenticatorTest() {
   }
 
  protected:
   void InitAuthenticators(
       const std::string& client_id,
       const std::string& client_paired_secret,
       const std::string& client_interactive_pin,
       const std::string& host_secret,
       AuthenticationMethod::HashFunction hash_function,
-      bool client_hmac_only,
-      scoped_refptr<PairingRegistry> pairing_registry) {
+      bool client_hmac_only) {
     std::string host_secret_hash = AuthenticationMethod::ApplyHashFunction(
         hash_function, kTestHostId, host_secret);
     host_ = NegotiatingHostAuthenticator::CreateWithSharedSecret(
         host_cert_, key_pair_, host_secret_hash, hash_function,
-        pairing_registry);
+        pairing_registry_);
 
     std::vector<AuthenticationMethod> methods;
     methods.push_back(AuthenticationMethod::Spake2Pair());
     methods.push_back(AuthenticationMethod::Spake2(
         AuthenticationMethod::HMAC_SHA256));
     if (!client_hmac_only) {
       methods.push_back(AuthenticationMethod::Spake2(
           AuthenticationMethod::NONE));
     }
-    bool pairing_expected = pairing_registry.get() != NULL;
+    bool pairing_expected = pairing_registry_.get() != NULL;
     FetchSecretCallback fetch_secret_callback =
         base::Bind(&NegotiatingAuthenticatorTest::FetchSecret,
                    client_interactive_pin,
                    pairing_expected);
     client_as_negotiating_authenticator_ = new NegotiatingClientAuthenticator(
         client_id, client_paired_secret,
         kTestHostId, fetch_secret_callback,
         scoped_ptr<ThirdPartyClientAuthenticator::TokenFetcher>(), methods);
     client_.reset(client_as_negotiating_authenticator_);
   }
 
-  scoped_refptr<PairingRegistry> CreatePairingRegistry(
-      PairingRegistry::Pairing* pairings, size_t num_pairings) {
-    PairingRegistry::PairedClients clients;
-    for (size_t i = 0; i < num_pairings; ++i) {
-      clients[pairings[i].client_id] = pairings[i];
+  void CreatePairingRegistry(bool with_paired_client) {
+    mock_delegate_ = new MockPairingRegistryDelegate;
+    if (with_paired_client) {
+      PairingRegistry::Pairing pairing;
+      pairing.client_id = kTestClientId;
+      pairing.shared_secret = kTestPairedSecret;
+      mock_delegate_->AddPairing(pairing);
     }
-    scoped_refptr<PairingRegistry> result(
-        new PairingRegistry(
-            scoped_ptr<PairingRegistry::Delegate>(
-                new NotImplementedPairingRegistryDelegate),
-            clients));
-    return result;
+    pairing_registry_ = new PairingRegistry(
+        scoped_ptr<PairingRegistry::Delegate>(mock_delegate_));
   }
 
   static void FetchSecret(
       const std::string& client_secret,
       bool pairing_supported,
       bool pairing_expected,
       const protocol::SecretFetchedCallback& secret_fetched_callback) {
     secret_fetched_callback.Run(client_secret);
     ASSERT_EQ(pairing_supported, pairing_expected);
   }
@@ skipping 29 matching lines @@
     message_loop_.Run();
     tester.CheckResults();
     EXPECT_EQ(
         expected_method,
         client_as_negotiating_authenticator_->current_method_for_testing());
   }
 
   // Use a bare pointer because the storage is managed by the base class.
   NegotiatingClientAuthenticator* client_as_negotiating_authenticator_;
 
+ protected:
+  MockPairingRegistryDelegate* mock_delegate_;
+
  private:
+  scoped_refptr<PairingRegistry> pairing_registry_;
+
   DISALLOW_COPY_AND_ASSIGN(NegotiatingAuthenticatorTest);
 };
 
 TEST_F(NegotiatingAuthenticatorTest, SuccessfulAuthHmac) {
   ASSERT_NO_FATAL_FAILURE(InitAuthenticators(
       kNoClientId, kNoPairedSecret, kTestPin, kTestPin,
-      AuthenticationMethod::HMAC_SHA256, false, NULL));
+      AuthenticationMethod::HMAC_SHA256, false));
   VerifyAccepted(
       AuthenticationMethod::Spake2(AuthenticationMethod::HMAC_SHA256));
 }
 
 TEST_F(NegotiatingAuthenticatorTest, SuccessfulAuthPlain) {
   ASSERT_NO_FATAL_FAILURE(InitAuthenticators(
       kNoClientId, kNoPairedSecret, kTestPin, kTestPin,
-      AuthenticationMethod::NONE, false, NULL));
+      AuthenticationMethod::NONE, false));
   VerifyAccepted(AuthenticationMethod::Spake2(AuthenticationMethod::NONE));
 }
 
 TEST_F(NegotiatingAuthenticatorTest, InvalidSecretHmac) {
   ASSERT_NO_FATAL_FAILURE(InitAuthenticators(
       kNoClientId, kNoPairedSecret, kTestPinBad, kTestPin,
-      AuthenticationMethod::HMAC_SHA256, false, NULL));
+      AuthenticationMethod::HMAC_SHA256, false));
   ASSERT_NO_FATAL_FAILURE(RunAuthExchange());
 
   VerifyRejected(Authenticator::INVALID_CREDENTIALS);
 }
 
 TEST_F(NegotiatingAuthenticatorTest, InvalidSecretPlain) {
   ASSERT_NO_FATAL_FAILURE(InitAuthenticators(
       kNoClientId, kNoPairedSecret, kTestPin, kTestPinBad,
-      AuthenticationMethod::NONE, false, NULL));
+      AuthenticationMethod::NONE, false));
   ASSERT_NO_FATAL_FAILURE(RunAuthExchange());
 
   VerifyRejected(Authenticator::INVALID_CREDENTIALS);
 }
 
 TEST_F(NegotiatingAuthenticatorTest, IncompatibleMethods) {
   ASSERT_NO_FATAL_FAILURE(InitAuthenticators(
       kNoClientId, kNoPairedSecret, kTestPin, kTestPinBad,
-      AuthenticationMethod::NONE, true, NULL));
+      AuthenticationMethod::NONE, true));
   ASSERT_NO_FATAL_FAILURE(RunAuthExchange());
 
   VerifyRejected(Authenticator::PROTOCOL_ERROR);
 }
 
 TEST_F(NegotiatingAuthenticatorTest, PairingNotSupported) {
   ASSERT_NO_FATAL_FAILURE(InitAuthenticators(
       kTestClientId, kTestPairedSecret, kTestPin, kTestPin,
-      AuthenticationMethod::HMAC_SHA256, false, NULL));
+      AuthenticationMethod::HMAC_SHA256, false));
   ASSERT_NO_FATAL_FAILURE(RunAuthExchange());
   VerifyAccepted(
       AuthenticationMethod::Spake2(AuthenticationMethod::HMAC_SHA256));
 }
 
 TEST_F(NegotiatingAuthenticatorTest, PairingSupportedButNotPaired) {
+  CreatePairingRegistry(false);
   ASSERT_NO_FATAL_FAILURE(InitAuthenticators(
       kNoClientId, kNoPairedSecret, kTestPin, kTestPin,
-      AuthenticationMethod::HMAC_SHA256, false,
-      CreatePairingRegistry(NULL, 0)));
+      AuthenticationMethod::HMAC_SHA256, false));
   ASSERT_NO_FATAL_FAILURE(RunAuthExchange());
   VerifyAccepted(AuthenticationMethod::Spake2Pair());
 }
 
 TEST_F(NegotiatingAuthenticatorTest, PairingRevokedPinOkay) {
+  CreatePairingRegistry(false);
   ASSERT_NO_FATAL_FAILURE(InitAuthenticators(
       kTestClientId, kTestPairedSecret, kTestPin, kTestPin,
-      AuthenticationMethod::HMAC_SHA256, false,
-      CreatePairingRegistry(NULL, 0)));
+      AuthenticationMethod::HMAC_SHA256, false));
   ASSERT_NO_FATAL_FAILURE(RunAuthExchange());
+  mock_delegate_->RunCallback();
   VerifyAccepted(AuthenticationMethod::Spake2Pair());
 }
 
 TEST_F(NegotiatingAuthenticatorTest, PairingRevokedPinBad) {
+  CreatePairingRegistry(false);
   ASSERT_NO_FATAL_FAILURE(InitAuthenticators(
       kTestClientId, kTestPairedSecret, kTestPinBad, kTestPin,
-      AuthenticationMethod::HMAC_SHA256, false,
-      CreatePairingRegistry(NULL, 0)));
+      AuthenticationMethod::HMAC_SHA256, false));
   ASSERT_NO_FATAL_FAILURE(RunAuthExchange());
+  mock_delegate_->RunCallback();
   VerifyRejected(Authenticator::INVALID_CREDENTIALS);
 }
 
 TEST_F(NegotiatingAuthenticatorTest, PairingSucceeded) {
-  PairingRegistry::Pairing pairing;
-  pairing.client_id = kTestClientId;
-  pairing.shared_secret = kTestPairedSecret;
+  CreatePairingRegistry(true);
   ASSERT_NO_FATAL_FAILURE(InitAuthenticators(
       kTestClientId, kTestPairedSecret, kTestPinBad, kTestPin,
-      AuthenticationMethod::HMAC_SHA256, false,
-      CreatePairingRegistry(&pairing, 1)));
+      AuthenticationMethod::HMAC_SHA256, false));
   ASSERT_NO_FATAL_FAILURE(RunAuthExchange());
+  mock_delegate_->RunCallback();
   VerifyAccepted(AuthenticationMethod::Spake2Pair());
 }
 
 TEST_F(NegotiatingAuthenticatorTest, PairingSucceededInvalidSecretButPinOkay) {
-  PairingRegistry::Pairing pairing;
-  pairing.client_id = kTestClientId;
-  pairing.shared_secret = kTestPairedSecret;
+  CreatePairingRegistry(true);
   ASSERT_NO_FATAL_FAILURE(InitAuthenticators(
       kTestClientId, kTestPairedSecretBad, kTestPin, kTestPin,
-      AuthenticationMethod::HMAC_SHA256, false,
-      CreatePairingRegistry(&pairing, 1)));
+      AuthenticationMethod::HMAC_SHA256, false));
   ASSERT_NO_FATAL_FAILURE(RunAuthExchange());
+  mock_delegate_->RunCallback();
   VerifyAccepted(AuthenticationMethod::Spake2Pair());
 }
 
 TEST_F(NegotiatingAuthenticatorTest, PairingFailedInvalidSecretAndPin) {
-  PairingRegistry::Pairing pairing;
-  pairing.client_id = kTestClientId;
-  pairing.shared_secret = kTestPairedSecret;
+  CreatePairingRegistry(true);
   ASSERT_NO_FATAL_FAILURE(InitAuthenticators(
       kTestClientId, kTestPairedSecretBad, kTestPinBad, kTestPin,
-      AuthenticationMethod::HMAC_SHA256, false,
-      CreatePairingRegistry(&pairing, 1)));
+      AuthenticationMethod::HMAC_SHA256, false));
   ASSERT_NO_FATAL_FAILURE(RunAuthExchange());
+  mock_delegate_->RunCallback();
   VerifyRejected(Authenticator::INVALID_CREDENTIALS);
 }
 
 }  // namespace protocol
 }  // namespace remoting