Change CryptoHandshakeMessage::GetTaglist to tag a QuicTagVector*

net/quic/core/crypto/crypto_handshake_message.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 "net/quic/core/crypto/crypto_handshake_message.h"
 
 #include <memory>
 
 #include "net/quic/core/crypto/crypto_framer.h"
 #include "net/quic/core/crypto/crypto_protocol.h"
@@ skipping 61 matching lines @@
 
 void CryptoHandshakeMessage::SetStringPiece(QuicTag tag,
                                             QuicStringPiece value) {
   tag_value_map_[tag] = value.as_string();
 }
 
 void CryptoHandshakeMessage::Erase(QuicTag tag) {
   tag_value_map_.erase(tag);
 }
 
-QuicErrorCode CryptoHandshakeMessage::GetTaglist(QuicTag tag,
-                                                 const QuicTag** out_tags,
-                                                 size_t* out_len) const {
+QuicErrorCode CryptoHandshakeMessage::GetTaglist(
+    QuicTag tag,
+    QuicTagVector* out_tags) const {
   QuicTagValueMap::const_iterator it = tag_value_map_.find(tag);
   QuicErrorCode ret = QUIC_NO_ERROR;
 
   if (it == tag_value_map_.end()) {
     ret = QUIC_CRYPTO_MESSAGE_PARAMETER_NOT_FOUND;
   } else if (it->second.size() % sizeof(QuicTag) != 0) {
     ret = QUIC_INVALID_CRYPTO_MESSAGE_PARAMETER;
   }
 
   if (ret != QUIC_NO_ERROR) {
-    *out_tags = nullptr;
-    *out_len = 0;
+    out_tags->clear();
     return ret;
   }
 
-  *out_tags = reinterpret_cast<const QuicTag*>(it->second.data());
-  *out_len = it->second.size() / sizeof(QuicTag);
+  size_t num_tags = it->second.size() / sizeof(QuicTag);
+  out_tags->resize(num_tags);
+  for (size_t i = 0; i < num_tags; ++i) {
+    QuicTag tag;
+    memcpy(&tag, it->second.data() + i * sizeof(tag), sizeof(tag));

[Nico, 2017/06/12 20:32:31]

A few short weeks later, I suddenly remembered this CL and that I forgot to
mention that you could've used
https://cs.chromium.org/chromium/src/base/bit_cast.h?type=cs&q=bit_cast+packa...
here if you can depend on base.

[Ryan Hamilton, 2017/06/12 20:48:41]

Ooo! That's good to know. We can depend on base (though perhaps via a wrapper)
and it looks like we have this function internally too. There are quite a few
places where we do memcpys like this which would also be candidates for
bit_cast.

Thanks!

+    (*out_tags)[i] = tag;
+  }
   return ret;
 }
 
 bool CryptoHandshakeMessage::GetStringPiece(QuicTag tag,
                                             QuicStringPiece* out) const {
   QuicTagValueMap::const_iterator it = tag_value_map_.find(tag);
   if (it == tag_value_map_.end()) {
     return false;
   }
   *out = it->second;
@@ skipping 217 matching lines @@
       ret += "0x" + QuicTextUtils::HexEncode(it->second);
     }
     ret += "\n";
   }
   --indent;
   ret += string(2 * indent, ' ') + ">";
   return ret;
 }
 
 }  // namespace net