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

webrtc/p2p/base/stun_unittest.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 <string>
 
-#include "webrtc/p2p/base/stun.h"
 #include "webrtc/base/arraysize.h"
 #include "webrtc/base/bytebuffer.h"
 #include "webrtc/base/gunit.h"
 #include "webrtc/base/logging.h"
 #include "webrtc/base/messagedigest.h"
+#include "webrtc/base/ptr_util.h"
 #include "webrtc/base/socketaddress.h"
+#include "webrtc/p2p/base/stun.h"
 
 namespace cricket {
 
 class StunTest : public ::testing::Test {
  protected:
   void CheckStunHeader(const StunMessage& msg, StunMessageType expected_type,
                        size_t expected_length) {
     ASSERT_EQ(expected_type, msg.type());
     ASSERT_EQ(expected_length, msg.length());
   }
@@ skipping 785 matching lines @@
   // However, no owner is still an error, should fail and write nothing.
   addr2.SetOwner(NULL);
   ASSERT_EQ(addr2.ipaddr(), addr->ipaddr());
   wrong_buf.Clear();
   EXPECT_FALSE(addr2.Write(&wrong_buf));
 }
 
 TEST_F(StunTest, CreateIPv6AddressAttribute) {
   rtc::IPAddress test_ip(kIPv6TestAddress2);
 
-  StunAddressAttribute* addr =
-      StunAttribute::CreateAddress(STUN_ATTR_MAPPED_ADDRESS);
+  auto addr = StunAttribute::CreateAddress(STUN_ATTR_MAPPED_ADDRESS);
   rtc::SocketAddress test_addr(test_ip, kTestMessagePort2);
   addr->SetAddress(test_addr);
 
-  CheckStunAddressAttribute(addr, STUN_ADDRESS_IPV6,
-                            kTestMessagePort2, test_ip);
-  delete addr;
+  CheckStunAddressAttribute(addr.get(), STUN_ADDRESS_IPV6, kTestMessagePort2,
+                            test_ip);
 }
 
 TEST_F(StunTest, CreateIPv4AddressAttribute) {
   struct in_addr test_in_addr;
   test_in_addr.s_addr = 0xBEB0B0BE;
   rtc::IPAddress test_ip(test_in_addr);
 
-  StunAddressAttribute* addr =
-      StunAttribute::CreateAddress(STUN_ATTR_MAPPED_ADDRESS);
+  auto addr = StunAttribute::CreateAddress(STUN_ATTR_MAPPED_ADDRESS);
   rtc::SocketAddress test_addr(test_ip, kTestMessagePort2);
   addr->SetAddress(test_addr);
 
-  CheckStunAddressAttribute(addr, STUN_ADDRESS_IPV4,
-                            kTestMessagePort2, test_ip);
-  delete addr;
+  CheckStunAddressAttribute(addr.get(), STUN_ADDRESS_IPV4, kTestMessagePort2,
+                            test_ip);
 }
 
 // Test that we don't care what order we set the parts of an address
 TEST_F(StunTest, CreateAddressInArbitraryOrder) {
-  StunAddressAttribute* addr =
-  StunAttribute::CreateAddress(STUN_ATTR_DESTINATION_ADDRESS);
+  auto addr = StunAttribute::CreateAddress(STUN_ATTR_DESTINATION_ADDRESS);
   // Port first
   addr->SetPort(kTestMessagePort1);
   addr->SetIP(rtc::IPAddress(kIPv4TestAddress1));
   ASSERT_EQ(kTestMessagePort1, addr->port());
   ASSERT_EQ(rtc::IPAddress(kIPv4TestAddress1), addr->ipaddr());
 
-  StunAddressAttribute* addr2 =
-  StunAttribute::CreateAddress(STUN_ATTR_DESTINATION_ADDRESS);
+  auto addr2 = StunAttribute::CreateAddress(STUN_ATTR_DESTINATION_ADDRESS);
   // IP first
   addr2->SetIP(rtc::IPAddress(kIPv4TestAddress1));
   addr2->SetPort(kTestMessagePort2);
   ASSERT_EQ(kTestMessagePort2, addr2->port());
   ASSERT_EQ(rtc::IPAddress(kIPv4TestAddress1), addr2->ipaddr());
-
-  delete addr;
-  delete addr2;
 }
 
 TEST_F(StunTest, WriteMessageWithIPv6AddressAttribute) {
   StunMessage msg;
   size_t size = sizeof(kStunMessageWithIPv6MappedAddress);
 
   rtc::IPAddress test_ip(kIPv6TestAddress1);
 
   msg.SetType(STUN_BINDING_REQUEST);
   msg.SetTransactionID(
       std::string(reinterpret_cast<const char*>(kTestTransactionId1),
                   kStunTransactionIdLength));
   CheckStunTransactionID(msg, kTestTransactionId1, kStunTransactionIdLength);
 
-  StunAddressAttribute* addr =
-      StunAttribute::CreateAddress(STUN_ATTR_MAPPED_ADDRESS);
+  auto addr = StunAttribute::CreateAddress(STUN_ATTR_MAPPED_ADDRESS);
   rtc::SocketAddress test_addr(test_ip, kTestMessagePort2);
   addr->SetAddress(test_addr);
-  msg.AddAttribute(addr);
+  msg.AddAttribute(std::move(addr));
 
   CheckStunHeader(msg, STUN_BINDING_REQUEST, (size - 20));
 
   rtc::ByteBufferWriter out;
   EXPECT_TRUE(msg.Write(&out));
   ASSERT_EQ(out.Length(), sizeof(kStunMessageWithIPv6MappedAddress));
   int len1 = static_cast<int>(out.Length());
   rtc::ByteBufferReader read_buf(out);
   std::string bytes;
   read_buf.ReadString(&bytes, len1);
   ASSERT_EQ(0, memcmp(bytes.c_str(), kStunMessageWithIPv6MappedAddress, len1));
 }
 
 TEST_F(StunTest, WriteMessageWithIPv4AddressAttribute) {
   StunMessage msg;
   size_t size = sizeof(kStunMessageWithIPv4MappedAddress);
 
   rtc::IPAddress test_ip(kIPv4TestAddress1);
 
   msg.SetType(STUN_BINDING_RESPONSE);
   msg.SetTransactionID(
       std::string(reinterpret_cast<const char*>(kTestTransactionId1),
                   kStunTransactionIdLength));
   CheckStunTransactionID(msg, kTestTransactionId1, kStunTransactionIdLength);
 
-  StunAddressAttribute* addr =
-      StunAttribute::CreateAddress(STUN_ATTR_MAPPED_ADDRESS);
+  auto addr = StunAttribute::CreateAddress(STUN_ATTR_MAPPED_ADDRESS);
   rtc::SocketAddress test_addr(test_ip, kTestMessagePort4);
   addr->SetAddress(test_addr);
-  msg.AddAttribute(addr);
+  msg.AddAttribute(std::move(addr));
 
   CheckStunHeader(msg, STUN_BINDING_RESPONSE, (size - 20));
 
   rtc::ByteBufferWriter out;
   EXPECT_TRUE(msg.Write(&out));
   ASSERT_EQ(out.Length(), sizeof(kStunMessageWithIPv4MappedAddress));
   int len1 = static_cast<int>(out.Length());
   rtc::ByteBufferReader read_buf(out);
   std::string bytes;
   read_buf.ReadString(&bytes, len1);
   ASSERT_EQ(0, memcmp(bytes.c_str(), kStunMessageWithIPv4MappedAddress, len1));
 }
 
 TEST_F(StunTest, WriteMessageWithIPv6XorAddressAttribute) {
   StunMessage msg;
   size_t size = sizeof(kStunMessageWithIPv6XorMappedAddress);
 
   rtc::IPAddress test_ip(kIPv6TestAddress1);
 
   msg.SetType(STUN_BINDING_RESPONSE);
   msg.SetTransactionID(
       std::string(reinterpret_cast<const char*>(kTestTransactionId2),
                   kStunTransactionIdLength));
   CheckStunTransactionID(msg, kTestTransactionId2, kStunTransactionIdLength);
 
-  StunAddressAttribute* addr =
-      StunAttribute::CreateXorAddress(STUN_ATTR_XOR_MAPPED_ADDRESS);
+  auto addr = StunAttribute::CreateXorAddress(STUN_ATTR_XOR_MAPPED_ADDRESS);
   rtc::SocketAddress test_addr(test_ip, kTestMessagePort1);
   addr->SetAddress(test_addr);
-  msg.AddAttribute(addr);
+  msg.AddAttribute(std::move(addr));
 
   CheckStunHeader(msg, STUN_BINDING_RESPONSE, (size - 20));
 
   rtc::ByteBufferWriter out;
   EXPECT_TRUE(msg.Write(&out));
   ASSERT_EQ(out.Length(), sizeof(kStunMessageWithIPv6XorMappedAddress));
   int len1 = static_cast<int>(out.Length());
   rtc::ByteBufferReader read_buf(out);
   std::string bytes;
   read_buf.ReadString(&bytes, len1);
   ASSERT_EQ(0,
             memcmp(bytes.c_str(), kStunMessageWithIPv6XorMappedAddress, len1));
 }
 
 TEST_F(StunTest, WriteMessageWithIPv4XoreAddressAttribute) {
   StunMessage msg;
   size_t size = sizeof(kStunMessageWithIPv4XorMappedAddress);
 
   rtc::IPAddress test_ip(kIPv4TestAddress1);
 
   msg.SetType(STUN_BINDING_RESPONSE);
   msg.SetTransactionID(
       std::string(reinterpret_cast<const char*>(kTestTransactionId1),
                   kStunTransactionIdLength));
   CheckStunTransactionID(msg, kTestTransactionId1, kStunTransactionIdLength);
 
-  StunAddressAttribute* addr =
-      StunAttribute::CreateXorAddress(STUN_ATTR_XOR_MAPPED_ADDRESS);
+  auto addr = StunAttribute::CreateXorAddress(STUN_ATTR_XOR_MAPPED_ADDRESS);
   rtc::SocketAddress test_addr(test_ip, kTestMessagePort3);
   addr->SetAddress(test_addr);
-  msg.AddAttribute(addr);
+  msg.AddAttribute(std::move(addr));
 
   CheckStunHeader(msg, STUN_BINDING_RESPONSE, (size - 20));
 
   rtc::ByteBufferWriter out;
   EXPECT_TRUE(msg.Write(&out));
   ASSERT_EQ(out.Length(), sizeof(kStunMessageWithIPv4XorMappedAddress));
   int len1 = static_cast<int>(out.Length());
   rtc::ByteBufferReader read_buf(out);
   std::string bytes;
   read_buf.ReadString(&bytes, len1);
@@ skipping 76 matching lines @@
 
 TEST_F(StunTest, WriteMessageWithAnErrorCodeAttribute) {
   StunMessage msg;
   size_t size = sizeof(kStunMessageWithErrorAttribute);
 
   msg.SetType(STUN_BINDING_ERROR_RESPONSE);
   msg.SetTransactionID(
       std::string(reinterpret_cast<const char*>(kTestTransactionId1),
                   kStunTransactionIdLength));
   CheckStunTransactionID(msg, kTestTransactionId1, kStunTransactionIdLength);
-  StunErrorCodeAttribute* errorcode = StunAttribute::CreateErrorCode();
+  auto errorcode = StunAttribute::CreateErrorCode();
   errorcode->SetCode(kTestErrorCode);
   errorcode->SetReason(kTestErrorReason);
-  msg.AddAttribute(errorcode);
+  msg.AddAttribute(std::move(errorcode));
   CheckStunHeader(msg, STUN_BINDING_ERROR_RESPONSE, (size - 20));
 
   rtc::ByteBufferWriter out;
   EXPECT_TRUE(msg.Write(&out));
   ASSERT_EQ(size, out.Length());
   // No padding.
   ASSERT_EQ(0, memcmp(out.Data(), kStunMessageWithErrorAttribute, size));
 }
 
 TEST_F(StunTest, WriteMessageWithAUInt16ListAttribute) {
   StunMessage msg;
   size_t size = sizeof(kStunMessageWithUInt16ListAttribute);
 
   msg.SetType(STUN_BINDING_REQUEST);
   msg.SetTransactionID(
       std::string(reinterpret_cast<const char*>(kTestTransactionId2),
                   kStunTransactionIdLength));
   CheckStunTransactionID(msg, kTestTransactionId2, kStunTransactionIdLength);
-  StunUInt16ListAttribute* list = StunAttribute::CreateUnknownAttributes();
+  auto list = StunAttribute::CreateUnknownAttributes();
   list->AddType(0x1U);
   list->AddType(0x1000U);
   list->AddType(0xAB0CU);
-  msg.AddAttribute(list);
+  msg.AddAttribute(std::move(list));
   CheckStunHeader(msg, STUN_BINDING_REQUEST, (size - 20));
 
   rtc::ByteBufferWriter out;
   EXPECT_TRUE(msg.Write(&out));
   ASSERT_EQ(size, out.Length());
   // Check everything up to the padding.
   ASSERT_EQ(0,
             memcmp(out.Data(), kStunMessageWithUInt16ListAttribute, size - 2));
 }
 
 TEST_F(StunTest, WriteMessageWithOriginAttribute) {
   StunMessage msg;
   size_t size = sizeof(kStunMessageWithOriginAttribute);
 
   msg.SetType(STUN_BINDING_REQUEST);
   msg.SetTransactionID(
       std::string(reinterpret_cast<const char*>(kTestTransactionId1),
                   kStunTransactionIdLength));
-  StunByteStringAttribute* origin =
-      new StunByteStringAttribute(STUN_ATTR_ORIGIN, kTestOrigin);
-  msg.AddAttribute(origin);
+  auto origin =
+      rtc::MakeUnique<StunByteStringAttribute>(STUN_ATTR_ORIGIN, kTestOrigin);
+  msg.AddAttribute(std::move(origin));
 
   rtc::ByteBufferWriter out;
   EXPECT_TRUE(msg.Write(&out));
   ASSERT_EQ(size, out.Length());
   // Check everything up to the padding
   ASSERT_EQ(0, memcmp(out.Data(), kStunMessageWithOriginAttribute, size - 2));
 }
 
 // Test that we fail to read messages with invalid lengths.
 void CheckFailureToRead(const unsigned char* testcase, size_t length) {
@@ skipping 248 matching lines @@
   in_addr legacy_in_addr;
   legacy_in_addr.s_addr = htonl(17U);
   rtc::IPAddress legacy_ip(legacy_in_addr);
 
   const StunAddressAttribute* addr = msg.GetAddress(STUN_ATTR_MAPPED_ADDRESS);
   ASSERT_TRUE(addr != NULL);
   EXPECT_EQ(1, addr->family());
   EXPECT_EQ(13, addr->port());
   EXPECT_EQ(legacy_ip, addr->ipaddr());
 
-  StunAddressAttribute* addr2 =
-      StunAttribute::CreateAddress(STUN_ATTR_MAPPED_ADDRESS);
+  auto addr2 = StunAttribute::CreateAddress(STUN_ATTR_MAPPED_ADDRESS);
   addr2->SetPort(13);
   addr2->SetIP(legacy_ip);
-  msg2.AddAttribute(addr2);
+  msg2.AddAttribute(std::move(addr2));
 
   const StunByteStringAttribute* bytes = msg.GetByteString(STUN_ATTR_USERNAME);
   ASSERT_TRUE(bytes != NULL);
   EXPECT_EQ(12U, bytes->length());
   EXPECT_EQ("abcdefghijkl", bytes->GetString());
 
-  StunByteStringAttribute* bytes2 =
-  StunAttribute::CreateByteString(STUN_ATTR_USERNAME);
+  auto bytes2 = StunAttribute::CreateByteString(STUN_ATTR_USERNAME);
   bytes2->CopyBytes("abcdefghijkl");
-  msg2.AddAttribute(bytes2);
+  msg2.AddAttribute(std::move(bytes2));
 
   const StunUInt32Attribute* uval = msg.GetUInt32(STUN_ATTR_LIFETIME);
   ASSERT_TRUE(uval != NULL);
   EXPECT_EQ(11U, uval->value());
 
-  StunUInt32Attribute* uval2 = StunAttribute::CreateUInt32(STUN_ATTR_LIFETIME);
+  auto uval2 = StunAttribute::CreateUInt32(STUN_ATTR_LIFETIME);
   uval2->SetValue(11);
-  msg2.AddAttribute(uval2);
+  msg2.AddAttribute(std::move(uval2));
 
   bytes = msg.GetByteString(STUN_ATTR_MAGIC_COOKIE);
   ASSERT_TRUE(bytes != NULL);
   EXPECT_EQ(4U, bytes->length());
   EXPECT_EQ(0,
             memcmp(bytes->bytes(),
                    TURN_MAGIC_COOKIE_VALUE,
                    sizeof(TURN_MAGIC_COOKIE_VALUE)));
 
   bytes2 = StunAttribute::CreateByteString(STUN_ATTR_MAGIC_COOKIE);
   bytes2->CopyBytes(reinterpret_cast<const char*>(TURN_MAGIC_COOKIE_VALUE),
                     sizeof(TURN_MAGIC_COOKIE_VALUE));
-  msg2.AddAttribute(bytes2);
+  msg2.AddAttribute(std::move(bytes2));
 
   uval = msg.GetUInt32(STUN_ATTR_BANDWIDTH);
   ASSERT_TRUE(uval != NULL);
   EXPECT_EQ(6U, uval->value());
 
   uval2 = StunAttribute::CreateUInt32(STUN_ATTR_BANDWIDTH);
   uval2->SetValue(6);
-  msg2.AddAttribute(uval2);
+  msg2.AddAttribute(std::move(uval2));
 
   addr = msg.GetAddress(STUN_ATTR_DESTINATION_ADDRESS);
   ASSERT_TRUE(addr != NULL);
   EXPECT_EQ(1, addr->family());
   EXPECT_EQ(13, addr->port());
   EXPECT_EQ(legacy_ip, addr->ipaddr());
 
   addr2 = StunAttribute::CreateAddress(STUN_ATTR_DESTINATION_ADDRESS);
   addr2->SetPort(13);
   addr2->SetIP(legacy_ip);
-  msg2.AddAttribute(addr2);
+  msg2.AddAttribute(std::move(addr2));
 
   addr = msg.GetAddress(STUN_ATTR_SOURCE_ADDRESS2);
   ASSERT_TRUE(addr != NULL);
   EXPECT_EQ(1, addr->family());
   EXPECT_EQ(13, addr->port());
   EXPECT_EQ(legacy_ip, addr->ipaddr());
 
   addr2 = StunAttribute::CreateAddress(STUN_ATTR_SOURCE_ADDRESS2);
   addr2->SetPort(13);
   addr2->SetIP(legacy_ip);
-  msg2.AddAttribute(addr2);
+  msg2.AddAttribute(std::move(addr2));
 
   bytes = msg.GetByteString(STUN_ATTR_DATA);
   ASSERT_TRUE(bytes != NULL);
   EXPECT_EQ(7U, bytes->length());
   EXPECT_EQ("abcdefg", bytes->GetString());
 
   bytes2 = StunAttribute::CreateByteString(STUN_ATTR_DATA);
   bytes2->CopyBytes("abcdefg");
-  msg2.AddAttribute(bytes2);
+  msg2.AddAttribute(std::move(bytes2));
 
   rtc::ByteBufferWriter out;
   EXPECT_TRUE(msg.Write(&out));
   EXPECT_EQ(size, out.Length());
   size_t len1 = out.Length();
   rtc::ByteBufferReader read_buf(out);
   std::string outstring;
   read_buf.ReadString(&outstring, len1);
   EXPECT_EQ(0, memcmp(outstring.c_str(), input, len1));
 
   rtc::ByteBufferWriter out2;
   EXPECT_TRUE(msg2.Write(&out2));
   EXPECT_EQ(size, out2.Length());
   size_t len2 = out2.Length();
   rtc::ByteBufferReader read_buf2(out2);
   std::string outstring2;
   read_buf2.ReadString(&outstring2, len2);
   EXPECT_EQ(0, memcmp(outstring2.c_str(), input, len2));
 }
 
 }  // namespace cricket