relnote: remove insecure QUIC support

net/quic/crypto/crypto_server_test.cc

 // Copyright (c) 2013 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 <ostream>
 #include <vector>
 
 #include "base/basictypes.h"
 #include "base/strings/string_number_conversions.h"
 #include "crypto/secure_hash.h"
@@ skipping 76 matching lines @@
     }
   }
   return params;
 }
 
 class CryptoServerTest : public ::testing::TestWithParam<TestParams> {
  public:
   CryptoServerTest()
       : rand_(QuicRandom::GetInstance()),
         client_address_(Loopback4(), 1234),
-        config_(QuicCryptoServerConfig::TESTING, rand_) {
-#if defined(USE_OPENSSL)
-    config_.SetProofSource(CryptoTestUtils::ProofSourceForTesting());
-#else
-    config_.SetProofSource(CryptoTestUtils::FakeProofSourceForTesting());
-#endif
+        config_(QuicCryptoServerConfig::TESTING,
+                rand_,
+                CryptoTestUtils::ProofSourceForTesting()) {
     supported_versions_ = QuicSupportedVersions();
     client_version_ = supported_versions_.front();
     client_version_string_ =
         QuicUtils::TagToString(QuicVersionToQuicTag(client_version_));
 
     FLAGS_use_early_return_when_verifying_chlo =
         GetParam().use_early_return_when_verifying_chlo;
     FLAGS_enable_quic_stateless_reject_support =
         GetParam().enable_stateless_rejects;
     use_stateless_rejects_ = GetParam().use_stateless_rejects;
@@ skipping 214 matching lines @@
 
   bool RejectsAreStateless() {
     return GetParam().enable_stateless_rejects &&
            GetParam().use_stateless_rejects;
   }
 
   string XlctHexString() {
     const vector<string>* certs;
     IPAddressNumber server_ip;
     string sig;
-#if defined(USE_OPENSSL)
     scoped_ptr<ProofSource> proof_source(
         CryptoTestUtils::ProofSourceForTesting());
-#else
-    scoped_ptr<ProofSource> proof_source(
-        CryptoTestUtils::FakeProofSourceForTesting());
-#endif
     if (!proof_source->GetProof(server_ip, "", "", false, &certs, &sig) ||
         certs->empty()) {
       return "#0100000000000000";
     }
 
     std::ostringstream xlct_stream;
     uint64 xlct =
         QuicUtils::FNV1a_64_Hash(certs->at(0).c_str(), certs->at(0).length());
     return "#" + base::HexEncode(reinterpret_cast<char*>(&xlct), sizeof(xlct));
   }
@@ skipping 391 matching lines @@
 }
 
 TEST(CryptoServerConfigGenerationTest, Determinism) {
   // Test that using a deterministic PRNG causes the server-config to be
   // deterministic.
 
   MockRandom rand_a, rand_b;
   const QuicCryptoServerConfig::ConfigOptions options;
   MockClock clock;
 
-  QuicCryptoServerConfig a(QuicCryptoServerConfig::TESTING, &rand_a);
-  QuicCryptoServerConfig b(QuicCryptoServerConfig::TESTING, &rand_b);
+  QuicCryptoServerConfig a(QuicCryptoServerConfig::TESTING, &rand_a,
+                           CryptoTestUtils::ProofSourceForTesting());
+  QuicCryptoServerConfig b(QuicCryptoServerConfig::TESTING, &rand_b,
+                           CryptoTestUtils::ProofSourceForTesting());
   scoped_ptr<CryptoHandshakeMessage> scfg_a(
       a.AddDefaultConfig(&rand_a, &clock, options));
   scoped_ptr<CryptoHandshakeMessage> scfg_b(
       b.AddDefaultConfig(&rand_b, &clock, options));
 
   ASSERT_EQ(scfg_a->DebugString(), scfg_b->DebugString());
 }
 
 TEST(CryptoServerConfigGenerationTest, SCIDVaries) {
   // This test ensures that the server config ID varies for different server
   // configs.
 
   MockRandom rand_a, rand_b;
   const QuicCryptoServerConfig::ConfigOptions options;
   MockClock clock;
 
-  QuicCryptoServerConfig a(QuicCryptoServerConfig::TESTING, &rand_a);
+  QuicCryptoServerConfig a(QuicCryptoServerConfig::TESTING, &rand_a,
+                           CryptoTestUtils::ProofSourceForTesting());
   rand_b.ChangeValue();
-  QuicCryptoServerConfig b(QuicCryptoServerConfig::TESTING, &rand_b);
+  QuicCryptoServerConfig b(QuicCryptoServerConfig::TESTING, &rand_b,
+                           CryptoTestUtils::ProofSourceForTesting());
   scoped_ptr<CryptoHandshakeMessage> scfg_a(
       a.AddDefaultConfig(&rand_a, &clock, options));
   scoped_ptr<CryptoHandshakeMessage> scfg_b(
       b.AddDefaultConfig(&rand_b, &clock, options));
 
   StringPiece scid_a, scid_b;
   EXPECT_TRUE(scfg_a->GetStringPiece(kSCID, &scid_a));
   EXPECT_TRUE(scfg_b->GetStringPiece(kSCID, &scid_b));
 
   EXPECT_NE(scid_a, scid_b);
 }
 
 TEST(CryptoServerConfigGenerationTest, SCIDIsHashOfServerConfig) {
   MockRandom rand_a;
   const QuicCryptoServerConfig::ConfigOptions options;
   MockClock clock;
 
-  QuicCryptoServerConfig a(QuicCryptoServerConfig::TESTING, &rand_a);
+  QuicCryptoServerConfig a(QuicCryptoServerConfig::TESTING, &rand_a,
+                           CryptoTestUtils::ProofSourceForTesting());
   scoped_ptr<CryptoHandshakeMessage> scfg(
       a.AddDefaultConfig(&rand_a, &clock, options));
 
   StringPiece scid;
   EXPECT_TRUE(scfg->GetStringPiece(kSCID, &scid));
   // Need to take a copy of |scid| has we're about to call |Erase|.
   const string scid_str(scid.as_string());
 
   scfg->Erase(kSCID);
   scfg->MarkDirty();
@@ skipping 155 matching lines @@
 
   strike_register_client_->RunPendingVerifications();
   ASSERT_TRUE(called);
   EXPECT_EQ(0, strike_register_client_->PendingVerifications());
   // The message should be rejected now.
   CheckRejectTag();
 }
 
 }  // namespace test
 }  // namespace net