Update from https://crrev.com/312398

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 24 matching lines @@
       : server_config_(server_config) {}
 
   base::Lock* GetStrikeRegisterClientLock() {
     return &server_config_->strike_register_client_lock_;
   }
 
  private:
   QuicCryptoServerConfig* server_config_;
 };
 
-// Run tests with combinations of
-// {FLAGS_use_early_return_when_verifying_chlo,
-//  FLAGS_send_quic_crypto_reject_reason}.
+// Run tests with both parities of
+// FLAGS_use_early_return_when_verifying_chlo.
 struct TestParams {
-  TestParams(bool use_early_return_when_verifying_chlo,
-             bool send_quic_crypto_reject_reason)
+  explicit TestParams(bool use_early_return_when_verifying_chlo)
       : use_early_return_when_verifying_chlo(
-            use_early_return_when_verifying_chlo),
-        send_quic_crypto_reject_reason(send_quic_crypto_reject_reason) {
-  }
+            use_early_return_when_verifying_chlo) {}
 
   friend ostream& operator<<(ostream& os, const TestParams& p) {
     os << "{ use_early_return_when_verifying_chlo: "
-       << p.use_early_return_when_verifying_chlo
-       << " send_quic_crypto_reject_reason: "
-       << p.send_quic_crypto_reject_reason << " }";
+       << p.use_early_return_when_verifying_chlo << " }";
     return os;
   }
 
   bool use_early_return_when_verifying_chlo;
-  bool send_quic_crypto_reject_reason;
 };
 
 // Constructs various test permutations.
 vector<TestParams> GetTestParams() {
   vector<TestParams> params;
-  params.push_back(TestParams(false, false));
-  params.push_back(TestParams(false, true));
-  params.push_back(TestParams(true, false));
-  params.push_back(TestParams(true, true));
+  params.push_back(TestParams(false));
+  params.push_back(TestParams(true));
   return params;
 }
 
 class CryptoServerTest : public ::testing::TestWithParam<TestParams> {
  public:
   CryptoServerTest()
       : rand_(QuicRandom::GetInstance()),
         client_address_(Loopback4(), 1234),
         config_(QuicCryptoServerConfig::TESTING, rand_) {
     config_.SetProofSource(CryptoTestUtils::ProofSourceForTesting());
     supported_versions_ = QuicSupportedVersions();
     client_version_ = QuicUtils::TagToString(
         QuicVersionToQuicTag(supported_versions_.front()));
 
     FLAGS_use_early_return_when_verifying_chlo =
         GetParam().use_early_return_when_verifying_chlo;
-    FLAGS_send_quic_crypto_reject_reason =
-        GetParam().send_quic_crypto_reject_reason;
   }
 
   void SetUp() override {
     scoped_ptr<CryptoHandshakeMessage> msg(
         config_.AddDefaultConfig(rand_, &clock_,
         config_options_));
 
     StringPiece orbit;
     CHECK(msg->GetStringPiece(kORBT, &orbit));
     CHECK_EQ(sizeof(orbit_), orbit.size());
@@ skipping 163 matching lines @@
         StringPiece(reinterpret_cast<const char*>(orbit_), sizeof(orbit_)),
         &nonce);
     return nonce;
   }
 
   void CheckRejectReasons(
       const HandshakeFailureReason* expected_handshake_failures,
       size_t expected_count) {
     const uint32* reject_reasons;
     size_t num_reject_reasons;
-    COMPILE_ASSERT(sizeof(QuicTag) == sizeof(uint32), header_out_of_sync);
+    static_assert(sizeof(QuicTag) == sizeof(uint32), "header out of sync");
     QuicErrorCode error_code = out_.GetTaglist(kRREJ, &reject_reasons,
                                                &num_reject_reasons);
-    if (!FLAGS_send_quic_crypto_reject_reason) {
-      ASSERT_EQ(QUIC_CRYPTO_MESSAGE_PARAMETER_NOT_FOUND, error_code);
-      return;
-    }
     ASSERT_EQ(QUIC_NO_ERROR, error_code);
 
     if (FLAGS_use_early_return_when_verifying_chlo) {
       EXPECT_EQ(1u, num_reject_reasons);
     } else {
       EXPECT_EQ(expected_count, num_reject_reasons);
     }
     for (size_t i = 0; i < num_reject_reasons; ++i) {
       EXPECT_EQ(expected_handshake_failures[i], reject_reasons[i]);
     }
@@ skipping 10 matching lines @@
   QuicCryptoNegotiatedParameters params_;
   CryptoHandshakeMessage out_;
   uint8 orbit_[kOrbitSize];
 
   // These strings contain hex escaped values from the server suitable for
   // passing to |InchoateClientHello| when constructing client hello messages.
   string nonce_hex_, pub_hex_, srct_hex_, scid_hex_;
   scoped_ptr<CryptoHandshakeMessage> server_config_;
 };
 
-// Run all CryptoServerTest with all combinations of
-// FLAGS_use_early_return_when_verifying_chlo and
-// FLAGS_send_quic_crypto_reject_reason.
+// Run all CryptoServerTest with both values of
+// FLAGS_use_early_return_when_verifying_chlo
 INSTANTIATE_TEST_CASE_P(CryptoServerTests,
                         CryptoServerTest,
                         ::testing::ValuesIn(GetTestParams()));
 
 TEST_P(CryptoServerTest, BadSNI) {
   static const char* kBadSNIs[] = {
     "",
     "foo",
     "#00",
     "#ff00",
@@ skipping 393 matching lines @@
 
   strike_register_client_->RunPendingVerifications();
   ASSERT_TRUE(called);
   EXPECT_EQ(0, strike_register_client_->PendingVerifications());
   // The message should be rejected now.
   EXPECT_EQ(kREJ, out_.tag());
 }
 
 }  // namespace test
 }  // namespace net