Make StunMessage::attrs_ a vector of unique_ptrs instead of a pointer to a vector of pointers.

webrtc/p2p/base/stun.cc

 /*
  *  Copyright 2004 The WebRTC Project Authors. All rights reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
@@ skipping 31 matching lines @@
 const char EMPTY_TRANSACTION_ID[] = "0000000000000000";
 const uint32_t STUN_FINGERPRINT_XOR_VALUE = 0x5354554E;
 
 // StunMessage
 
 StunMessage::StunMessage()
     : type_(0),
       length_(0),
       transaction_id_(EMPTY_TRANSACTION_ID) {
   RTC_DCHECK(IsValidTransactionId(transaction_id_));
-  attrs_ = new std::vector<StunAttribute*>();
-}
-
-StunMessage::~StunMessage() {
-  for (size_t i = 0; i < attrs_->size(); i++)
-    delete (*attrs_)[i];
-  delete attrs_;
 }
 
 bool StunMessage::IsLegacy() const {
   if (transaction_id_.size() == kStunLegacyTransactionIdLength)
     return true;
   RTC_DCHECK(transaction_id_.size() == kStunTransactionIdLength);
   return false;
 }
 
 bool StunMessage::SetTransactionID(const std::string& str) {
   if (!IsValidTransactionId(str)) {
     return false;
   }
   transaction_id_ = str;
   return true;
 }
 
 void StunMessage::AddAttribute(StunAttribute* attr) {
   // Fail any attributes that aren't valid for this type of message.
   RTC_DCHECK_EQ(attr->value_type(), GetAttributeValueType(attr->type()));
 
-  attrs_->push_back(attr);
+  attrs_.emplace_back(attr);
   attr->SetOwner(this);
   size_t attr_length = attr->length();
   if (attr_length % 4 != 0) {
     attr_length += (4 - (attr_length % 4));
   }
   length_ += static_cast<uint16_t>(attr_length + 4);
 }
 
 const StunAddressAttribute* StunMessage::GetAddress(int type) const {
   switch (type) {
@@ skipping 230 matching lines @@
     // If magic cookie is invalid it means that the peer implements
     // RFC3489 instead of RFC5389.
     transaction_id.insert(0, magic_cookie);
   }
   RTC_DCHECK(IsValidTransactionId(transaction_id));
   transaction_id_ = transaction_id;
 
   if (length_ != buf->Length())
     return false;
 
-  attrs_->resize(0);
+  attrs_.resize(0);
 
   size_t rest = buf->Length() - length_;
   while (buf->Length() > rest) {
     uint16_t attr_type, attr_length;
     if (!buf->ReadUInt16(&attr_type))
       return false;
     if (!buf->ReadUInt16(&attr_length))
       return false;
 
     std::unique_ptr<StunAttribute> attr(
         CreateAttribute(attr_type, attr_length));
     if (!attr) {
       // Skip any unknown or malformed attributes.
       if ((attr_length % 4) != 0) {
         attr_length += (4 - (attr_length % 4));
       }
       if (!buf->Consume(attr_length))
         return false;
     } else {
       if (!attr->Read(buf))
         return false;
-      // TODO(honghaiz): Change |attrs_| to be a vector of unique_ptrs.
-      attrs_->push_back(attr.release());
+      attrs_.push_back(std::move(attr));
     }
   }
 
   RTC_DCHECK(buf->Length() == rest);
   return true;
 }
 
 bool StunMessage::Write(ByteBufferWriter* buf) const {
   buf->WriteUInt16(type_);
   buf->WriteUInt16(length_);
   if (!IsLegacy())
     buf->WriteUInt32(kStunMagicCookie);
   buf->WriteString(transaction_id_);
 
-  for (size_t i = 0; i < attrs_->size(); ++i) {
-    buf->WriteUInt16((*attrs_)[i]->type());
-    buf->WriteUInt16(static_cast<uint16_t>((*attrs_)[i]->length()));
-    if (!(*attrs_)[i]->Write(buf))
+  for (const auto& attr : attrs_) {
+    buf->WriteUInt16(attr->type());
+    buf->WriteUInt16(static_cast<uint16_t>(attr->length()));
+    if (!attr->Write(buf)) {
       return false;
+    }
   }
 
   return true;
 }
 
 StunAttributeValueType StunMessage::GetAttributeValueType(int type) const {
   switch (type) {
     case STUN_ATTR_MAPPED_ADDRESS:      return STUN_VALUE_ADDRESS;
     case STUN_ATTR_USERNAME:            return STUN_VALUE_BYTE_STRING;
     case STUN_ATTR_MESSAGE_INTEGRITY:   return STUN_VALUE_BYTE_STRING;
@@ skipping 11 matching lines @@
   }
 }
 
 StunAttribute* StunMessage::CreateAttribute(int type, size_t length) /*const*/ {
   StunAttributeValueType value_type = GetAttributeValueType(type);
   return StunAttribute::Create(value_type, type, static_cast<uint16_t>(length),
                                this);
 }
 
 const StunAttribute* StunMessage::GetAttribute(int type) const {
-  for (size_t i = 0; i < attrs_->size(); ++i) {
-    if ((*attrs_)[i]->type() == type)
-      return (*attrs_)[i];
+  for (const auto& attr : attrs_) {
+    if (attr->type() == type) {
+      return attr.get();
+    }
   }
   return NULL;
 }
 
 bool StunMessage::IsValidTransactionId(const std::string& transaction_id) {
   return transaction_id.size() == kStunTransactionIdLength ||
       transaction_id.size() == kStunLegacyTransactionIdLength;
 }
 
 // StunAttribute
@@ skipping 494 matching lines @@
       digest, sizeof(digest));
   if (size == 0) {
     return false;
   }
 
   *hash = std::string(digest, size);
   return true;
 }
 
 }  // namespace cricket