Refactored PairingRegistry::Delegate such that it can retrieve/modify for a single client.

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"
@@ skipping 66 matching lines @@
                    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_);
   }
 
   void CreatePairingRegistry(bool with_paired_client) {
-    mock_delegate_ = new MockPairingRegistryDelegate;
-    pairing_registry_ = new PairingRegistry(
-        scoped_ptr<PairingRegistry::Delegate>(mock_delegate_));
+    pairing_registry_ = new SynchronousPairingRegistry(
+        scoped_ptr<PairingRegistry::Delegate>(
+            new MockPairingRegistryDelegate()));
     if (with_paired_client) {
       PairingRegistry::Pairing pairing(
           base::Time(), kTestClientName, kTestClientId, kTestPairedSecret);
       pairing_registry_->AddPairing(pairing);
-      mock_delegate_->RunCallback();
     }
   }
 
   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 30 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));
@@ skipping 52 matching lines @@
   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));
   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));
   ASSERT_NO_FATAL_FAILURE(RunAuthExchange());
-  mock_delegate_->RunCallback();
   VerifyRejected(Authenticator::INVALID_CREDENTIALS);
 }
 
 TEST_F(NegotiatingAuthenticatorTest, PairingSucceeded) {
   CreatePairingRegistry(true);
   ASSERT_NO_FATAL_FAILURE(InitAuthenticators(
       kTestClientId, kTestPairedSecret, kTestPinBad, kTestPin,
       AuthenticationMethod::HMAC_SHA256, false));
   ASSERT_NO_FATAL_FAILURE(RunAuthExchange());
-  mock_delegate_->RunCallback();
   VerifyAccepted(AuthenticationMethod::Spake2Pair());
 }
 
 TEST_F(NegotiatingAuthenticatorTest, PairingSucceededInvalidSecretButPinOkay) {
   CreatePairingRegistry(true);
   ASSERT_NO_FATAL_FAILURE(InitAuthenticators(
       kTestClientId, kTestPairedSecretBad, kTestPin, kTestPin,
       AuthenticationMethod::HMAC_SHA256, false));
   ASSERT_NO_FATAL_FAILURE(RunAuthExchange());
-  mock_delegate_->RunCallback();
   VerifyAccepted(AuthenticationMethod::Spake2Pair());
 }
 
 TEST_F(NegotiatingAuthenticatorTest, PairingFailedInvalidSecretAndPin) {
   CreatePairingRegistry(true);
   ASSERT_NO_FATAL_FAILURE(InitAuthenticators(
       kTestClientId, kTestPairedSecretBad, kTestPinBad, kTestPin,
       AuthenticationMethod::HMAC_SHA256, false));
   ASSERT_NO_FATAL_FAILURE(RunAuthExchange());
-  mock_delegate_->RunCallback();
   VerifyRejected(Authenticator::INVALID_CREDENTIALS);
 }
 
 }  // namespace protocol
 }  // namespace remoting