Add MakeUnique from chromium and change StunMessage::AddAttribute to take a unique_ptr.

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.
  */
 
 #include "webrtc/p2p/base/stun.h"
 
 #include <string.h>
 
 #include <memory>
 
 #include "webrtc/base/byteorder.h"
 #include "webrtc/base/checks.h"
 #include "webrtc/base/crc32.h"
 #include "webrtc/base/logging.h"
 #include "webrtc/base/messagedigest.h"
+#include "webrtc/base/ptr_util.h"
 #include "webrtc/base/stringencode.h"
 
 using rtc::ByteBufferReader;
 using rtc::ByteBufferWriter;
 
 namespace cricket {
 
 const char STUN_ERROR_REASON_TRY_ALTERNATE_SERVER[] = "Try Alternate Server";
 const char STUN_ERROR_REASON_BAD_REQUEST[] = "Bad Request";
 const char STUN_ERROR_REASON_UNAUTHORIZED[] = "Unauthorized";
@@ skipping 27 matching lines @@
 }
 
 bool StunMessage::SetTransactionID(const std::string& str) {
   if (!IsValidTransactionId(str)) {
     return false;
   }
   transaction_id_ = str;
   return true;
 }
 
-void StunMessage::AddAttribute(StunAttribute* attr) {
+void StunMessage::AddAttribute(std::unique_ptr<StunAttribute> attr) {
   // Fail any attributes that aren't valid for this type of message.
   RTC_DCHECK_EQ(attr->value_type(), GetAttributeValueType(attr->type()));
 
-  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);
+
+  attrs_.push_back(std::move(attr));
 }
 
 const StunAddressAttribute* StunMessage::GetAddress(int type) const {
   switch (type) {
     case STUN_ATTR_MAPPED_ADDRESS: {
       // Return XOR-MAPPED-ADDRESS when MAPPED-ADDRESS attribute is
       // missing.
       const StunAttribute* mapped_address =
           GetAttribute(STUN_ATTR_MAPPED_ADDRESS);
       if (!mapped_address)
@@ skipping 110 matching lines @@
 }
 
 bool StunMessage::AddMessageIntegrity(const std::string& password) {
   return AddMessageIntegrity(password.c_str(), password.size());
 }
 
 bool StunMessage::AddMessageIntegrity(const char* key,
                                       size_t keylen) {
   // Add the attribute with a dummy value. Since this is a known attribute, it
   // can't fail.
-  StunByteStringAttribute* msg_integrity_attr =
-      new StunByteStringAttribute(STUN_ATTR_MESSAGE_INTEGRITY,
-          std::string(kStunMessageIntegritySize, '0'));
-  AddAttribute(msg_integrity_attr);
+  auto msg_integrity_attr_ptr = rtc::MakeUnique<StunByteStringAttribute>(
+      STUN_ATTR_MESSAGE_INTEGRITY, std::string(kStunMessageIntegritySize, '0'));
+  auto* msg_integrity_attr = msg_integrity_attr_ptr.get();
+  AddAttribute(std::move(msg_integrity_attr_ptr));
 
   // Calculate the HMAC for the message.
   ByteBufferWriter buf;
   if (!Write(&buf))
     return false;
 
   int msg_len_for_hmac = static_cast<int>(
       buf.Length() - kStunAttributeHeaderSize - msg_integrity_attr->length());
   char hmac[kStunMessageIntegritySize];
   size_t ret = rtc::ComputeHmac(rtc::DIGEST_SHA_1,
@@ skipping 38 matching lines @@
   // Check the fingerprint value.
   uint32_t fingerprint =
       rtc::GetBE32(fingerprint_attr_data + kStunAttributeHeaderSize);
   return ((fingerprint ^ STUN_FINGERPRINT_XOR_VALUE) ==
       rtc::ComputeCrc32(data, size - fingerprint_attr_size));
 }
 
 bool StunMessage::AddFingerprint() {
   // Add the attribute with a dummy value. Since this is a known attribute,
   // it can't fail.
-  StunUInt32Attribute* fingerprint_attr =
-     new StunUInt32Attribute(STUN_ATTR_FINGERPRINT, 0);
-  AddAttribute(fingerprint_attr);
+  auto fingerprint_attr_ptr =
+      rtc::MakeUnique<StunUInt32Attribute>(STUN_ATTR_FINGERPRINT, 0);
+  auto fingerprint_attr = fingerprint_attr_ptr.get();
+  AddAttribute(std::move(fingerprint_attr_ptr));
 
   // Calculate the CRC-32 for the message and insert it.
   ByteBufferWriter buf;
   if (!Write(&buf))
     return false;
 
   int msg_len_for_crc32 = static_cast<int>(
       buf.Length() - kStunAttributeHeaderSize - fingerprint_attr->length());
   uint32_t c = rtc::ComputeCrc32(buf.Data(), msg_len_for_crc32);
 
@@ skipping 161 matching lines @@
       return new StunByteStringAttribute(type, length);
     case STUN_VALUE_ERROR_CODE:
       return new StunErrorCodeAttribute(type, length);
     case STUN_VALUE_UINT16_LIST:
       return new StunUInt16ListAttribute(type, length);
     default:
       return NULL;
   }
 }
 
-StunAddressAttribute* StunAttribute::CreateAddress(uint16_t type) {
-  return new StunAddressAttribute(type, 0);
+std::unique_ptr<StunAddressAttribute> StunAttribute::CreateAddress(
+    uint16_t type) {
+  return rtc::MakeUnique<StunAddressAttribute>(type, 0);
 }
 
-StunXorAddressAttribute* StunAttribute::CreateXorAddress(uint16_t type) {
-  return new StunXorAddressAttribute(type, 0, NULL);
+std::unique_ptr<StunXorAddressAttribute> StunAttribute::CreateXorAddress(
+    uint16_t type) {
+  return rtc::MakeUnique<StunXorAddressAttribute>(type, 0, nullptr);
 }
 
-StunUInt64Attribute* StunAttribute::CreateUInt64(uint16_t type) {
-  return new StunUInt64Attribute(type);
+std::unique_ptr<StunUInt64Attribute> StunAttribute::CreateUInt64(
+    uint16_t type) {
+  return rtc::MakeUnique<StunUInt64Attribute>(type);
 }
 
-StunUInt32Attribute* StunAttribute::CreateUInt32(uint16_t type) {
-  return new StunUInt32Attribute(type);
+std::unique_ptr<StunUInt32Attribute> StunAttribute::CreateUInt32(
+    uint16_t type) {
+  return rtc::MakeUnique<StunUInt32Attribute>(type);
 }
 
-StunByteStringAttribute* StunAttribute::CreateByteString(uint16_t type) {
-  return new StunByteStringAttribute(type, 0);
+std::unique_ptr<StunByteStringAttribute> StunAttribute::CreateByteString(
+    uint16_t type) {
+  return rtc::MakeUnique<StunByteStringAttribute>(type, 0);
 }
 
-StunErrorCodeAttribute* StunAttribute::CreateErrorCode() {
-  return new StunErrorCodeAttribute(
+std::unique_ptr<StunErrorCodeAttribute> StunAttribute::CreateErrorCode() {
+  return rtc::MakeUnique<StunErrorCodeAttribute>(
       STUN_ATTR_ERROR_CODE, StunErrorCodeAttribute::MIN_SIZE);
 }
 
-StunUInt16ListAttribute* StunAttribute::CreateUnknownAttributes() {
-  return new StunUInt16ListAttribute(STUN_ATTR_UNKNOWN_ATTRIBUTES, 0);
+std::unique_ptr<StunUInt16ListAttribute>
+StunAttribute::CreateUnknownAttributes() {
+  return rtc::MakeUnique<StunUInt16ListAttribute>(STUN_ATTR_UNKNOWN_ATTRIBUTES,
+                                                  0);
 }
 
 StunAddressAttribute::StunAddressAttribute(uint16_t type,
                                            const rtc::SocketAddress& addr)
     : StunAttribute(type, 0) {
   SetAddress(addr);
 }
 
 StunAddressAttribute::StunAddressAttribute(uint16_t type, uint16_t length)
     : StunAttribute(type, length) {
@@ skipping 256 matching lines @@
   WritePadding(buf);
   return true;
 }
 
 void StunByteStringAttribute::SetBytes(char* bytes, size_t length) {
   delete [] bytes_;
   bytes_ = bytes;
   SetLength(static_cast<uint16_t>(length));
 }
 
+const uint16_t StunErrorCodeAttribute::MIN_SIZE = 4;
+
 StunErrorCodeAttribute::StunErrorCodeAttribute(uint16_t type,
                                                int code,
                                                const std::string& reason)
     : StunAttribute(type, 0) {
   SetCode(code);
   SetReason(reason);
 }
 
 StunErrorCodeAttribute::StunErrorCodeAttribute(uint16_t type, uint16_t length)
     : StunAttribute(type, length), class_(0), number_(0) {
@@ skipping 137 matching lines @@
       digest, sizeof(digest));
   if (size == 0) {
     return false;
   }
 
   *hash = std::string(digest, size);
   return true;
 }
 
 }  // namespace cricket