Change CryptoHandshakeMessage::GetTaglist to tag a QuicTagVector*

net/quic/core/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 <algorithm>
 #include <cstdint>
 #include <memory>
 #include <ostream>
 #include <vector>
 
@@ skipping 198 matching lines @@
     }
 
    private:
     CryptoServerTest* test_;
     const bool should_succeed_;
     const char* const error_substr_;
     bool* called_;
   };
 
   void CheckServerHello(const CryptoHandshakeMessage& server_hello) {
-    const QuicTag* versions;
-    size_t num_versions;
-    server_hello.GetTaglist(kVER, &versions, &num_versions);
-    ASSERT_EQ(supported_versions_.size(), num_versions);
-    for (size_t i = 0; i < num_versions; ++i) {
+    QuicTagVector versions;
+    server_hello.GetTaglist(kVER, &versions);
+    ASSERT_EQ(supported_versions_.size(), versions.size());
+    for (size_t i = 0; i < versions.size(); ++i) {
       EXPECT_EQ(QuicVersionToQuicTag(supported_versions_[i]), versions[i]);
     }
 
     QuicStringPiece address;
     ASSERT_TRUE(server_hello.GetStringPiece(kCADR, &address));
     QuicSocketAddressCoder decoder;
     ASSERT_TRUE(decoder.Decode(address.data(), address.size()));
     EXPECT_EQ(client_address_.host(), decoder.ip());
     EXPECT_EQ(client_address_.port(), decoder.port());
   }
@@ skipping 99 matching lines @@
     CryptoUtils::GenerateNonce(
         clock_.WallNow(), rand_,
         QuicStringPiece(reinterpret_cast<const char*>(orbit_), sizeof(orbit_)),
         &nonce);
     return nonce;
   }
 
   void CheckRejectReasons(
       const HandshakeFailureReason* expected_handshake_failures,
       size_t expected_count) {
-    const uint32_t* reject_reasons;
-    size_t num_reject_reasons;
+    QuicTagVector reject_reasons;
     static_assert(sizeof(QuicTag) == sizeof(uint32_t), "header out of sync");
-    QuicErrorCode error_code =
-        out_.GetTaglist(kRREJ, &reject_reasons, &num_reject_reasons);
+    QuicErrorCode error_code = out_.GetTaglist(kRREJ, &reject_reasons);
     ASSERT_EQ(QUIC_NO_ERROR, error_code);
 
-    EXPECT_EQ(expected_count, num_reject_reasons);
-    for (size_t i = 0; i < num_reject_reasons; ++i) {
+    EXPECT_EQ(expected_count, reject_reasons.size());
+    for (size_t i = 0; i < reject_reasons.size(); ++i) {
       EXPECT_EQ(expected_handshake_failures[i], reject_reasons[i]);
     }
   }
 
   // If the server is rejecting statelessly, make sure it contains a
   // server-designated connection id.  Once the check is complete,
   // allow the random id-generator to move to the next value.
   void CheckForServerDesignatedConnectionId() {
     QuicConnectionId server_designated_connection_id;
     if (!RejectsAreStateless()) {
@@ skipping 728 matching lines @@
   // QuicCryptoServerConfig::EvaluateClientHello will leave info.unique as false
   // and cause ProcessClientHello to exit early (and generate a REJ message).
   config_.set_replay_protection(false);
 
   ShouldSucceed(msg);
   EXPECT_EQ(kSHLO, out_.tag());
 }
 
 }  // namespace test
 }  // namespace net