Remove QuicFramer::encrypter, because it's a test-only method.

net/quic/test_tools/crypto_test_utils.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 "net/quic/test_tools/crypto_test_utils.h"
 
 #include "net/quic/crypto/channel_id.h"
 #include "net/quic/crypto/common_cert_set.h"
 #include "net/quic/crypto/crypto_handshake.h"
 #include "net/quic/crypto/quic_crypto_server_config.h"
 #include "net/quic/crypto/quic_decrypter.h"
 #include "net/quic/crypto/quic_encrypter.h"
 #include "net/quic/crypto/quic_random.h"
 #include "net/quic/quic_clock.h"
 #include "net/quic/quic_crypto_client_stream.h"
 #include "net/quic/quic_crypto_server_stream.h"
 #include "net/quic/quic_crypto_stream.h"
 #include "net/quic/quic_server_id.h"
 #include "net/quic/test_tools/quic_connection_peer.h"
+#include "net/quic/test_tools/quic_framer_peer.h"
 #include "net/quic/test_tools/quic_test_utils.h"
 #include "net/quic/test_tools/simple_quic_framer.h"
 
 using base::StringPiece;
 using std::make_pair;
 using std::pair;
 using std::string;
 using std::vector;
 
 namespace net {
@@ skipping 374 matching lines @@
 
 CommonCertSets* CryptoTestUtils::MockCommonCertSets(StringPiece cert,
                                                     uint64 hash,
                                                     uint32 index) {
   return new class MockCommonCertSets(cert, hash, index);
 }
 
 void CryptoTestUtils::CompareClientAndServerKeys(
     QuicCryptoClientStream* client,
     QuicCryptoServerStream* server) {
+  QuicFramer* client_framer =
+      QuicConnectionPeer::GetFramer(client->session()->connection());
+  QuicFramer* server_framer =
+      QuicConnectionPeer::GetFramer(server->session()->connection());
   const QuicEncrypter* client_encrypter(
-      client->session()->connection()->encrypter(ENCRYPTION_INITIAL));
+      QuicFramerPeer::GetEncrypter(client_framer, ENCRYPTION_INITIAL));
   const QuicDecrypter* client_decrypter(
       client->session()->connection()->decrypter());
   const QuicEncrypter* client_forward_secure_encrypter(
-      client->session()->connection()->encrypter(ENCRYPTION_FORWARD_SECURE));
+      QuicFramerPeer::GetEncrypter(client_framer, ENCRYPTION_FORWARD_SECURE));
   const QuicDecrypter* client_forward_secure_decrypter(
       client->session()->connection()->alternative_decrypter());
   const QuicEncrypter* server_encrypter(
-      server->session()->connection()->encrypter(ENCRYPTION_INITIAL));
+      QuicFramerPeer::GetEncrypter(server_framer, ENCRYPTION_INITIAL));
   const QuicDecrypter* server_decrypter(
       server->session()->connection()->decrypter());
   const QuicEncrypter* server_forward_secure_encrypter(
-      server->session()->connection()->encrypter(ENCRYPTION_FORWARD_SECURE));
+      QuicFramerPeer::GetEncrypter(server_framer, ENCRYPTION_FORWARD_SECURE));
   const QuicDecrypter* server_forward_secure_decrypter(
       server->session()->connection()->alternative_decrypter());
 
   StringPiece client_encrypter_key = client_encrypter->GetKey();
   StringPiece client_encrypter_iv = client_encrypter->GetNoncePrefix();
   StringPiece client_decrypter_key = client_decrypter->GetKey();
   StringPiece client_decrypter_iv = client_decrypter->GetNoncePrefix();
   StringPiece client_forward_secure_encrypter_key =
       client_forward_secure_encrypter->GetKey();
   StringPiece client_forward_secure_encrypter_iv =
@@ skipping 187 matching lines @@
   scoped_ptr<QuicData> bytes(CryptoFramer::ConstructHandshakeMessage(msg));
   scoped_ptr<CryptoHandshakeMessage> parsed(
       CryptoFramer::ParseMessage(bytes->AsStringPiece()));
   CHECK(parsed.get());
 
   return *parsed;
 }
 
 }  // namespace test
 }  // namespace net