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

webrtc/p2p/base/relayserver_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.
  */
 
@@ skipping 128 matching lines @@
   }
 
   static StunMessage* CreateStunMessage(int type) {
     StunMessage* msg = new RelayMessage();
     msg->SetType(type);
     msg->SetTransactionID(
         rtc::CreateRandomString(kStunTransactionIdLength));
     return msg;
   }
   static void AddMagicCookieAttr(StunMessage* msg) {
-    StunByteStringAttribute* attr =
-        StunAttribute::CreateByteString(STUN_ATTR_MAGIC_COOKIE);
+    auto attr = StunAttribute::CreateByteString(STUN_ATTR_MAGIC_COOKIE);
     attr->CopyBytes(TURN_MAGIC_COOKIE_VALUE, sizeof(TURN_MAGIC_COOKIE_VALUE));
-    msg->AddAttribute(attr);
+    msg->AddAttribute(std::move(attr));
   }
   static void AddUsernameAttr(StunMessage* msg, const std::string& val) {
-    StunByteStringAttribute* attr =
-        StunAttribute::CreateByteString(STUN_ATTR_USERNAME);
+    auto attr = StunAttribute::CreateByteString(STUN_ATTR_USERNAME);
     attr->CopyBytes(val.c_str(), val.size());
-    msg->AddAttribute(attr);
+    msg->AddAttribute(std::move(attr));
   }
   static void AddLifetimeAttr(StunMessage* msg, int val) {
-    StunUInt32Attribute* attr =
-        StunAttribute::CreateUInt32(STUN_ATTR_LIFETIME);
+    auto attr = StunAttribute::CreateUInt32(STUN_ATTR_LIFETIME);
     attr->SetValue(val);
-    msg->AddAttribute(attr);
+    msg->AddAttribute(std::move(attr));
   }
   static void AddDestinationAttr(StunMessage* msg, const SocketAddress& addr) {
-    StunAddressAttribute* attr =
-        StunAttribute::CreateAddress(STUN_ATTR_DESTINATION_ADDRESS);
+    auto attr = StunAttribute::CreateAddress(STUN_ATTR_DESTINATION_ADDRESS);
     attr->SetIP(addr.ipaddr());
     attr->SetPort(addr.port());
-    msg->AddAttribute(attr);
+    msg->AddAttribute(std::move(attr));
   }
 
   std::unique_ptr<rtc::PhysicalSocketServer> pss_;
   std::unique_ptr<rtc::VirtualSocketServer> ss_;
   rtc::SocketServerScope ss_scope_;
   std::unique_ptr<RelayServer> server_;
   std::unique_ptr<rtc::TestClient> client1_;
   std::unique_ptr<rtc::TestClient> client2_;
   std::string username_;
   std::string password_;
@@ skipping 269 matching lines @@
 TEST_F(RelayServerTest, TestSendRaw) {
   Allocate();
   Bind();
 
   for (int i = 0; i < 10; i++) {
     std::unique_ptr<StunMessage> req(CreateStunMessage(STUN_SEND_REQUEST)), res;
     AddMagicCookieAttr(req.get());
     AddUsernameAttr(req.get(), username_);
     AddDestinationAttr(req.get(), client2_addr);
 
-    StunByteStringAttribute* send_data =
-        StunAttribute::CreateByteString(STUN_ATTR_DATA);
+    auto send_data = StunAttribute::CreateByteString(STUN_ATTR_DATA);
     send_data->CopyBytes(msg1);
-    req->AddAttribute(send_data);
+    req->AddAttribute(std::move(send_data));
 
     Send1(req.get());
     EXPECT_EQ(msg1, ReceiveRaw2());
     SendRaw2(msg2, static_cast<int>(strlen(msg2)));
     res.reset(Receive1());
 
     ASSERT_TRUE(res);
     EXPECT_EQ(STUN_DATA_INDICATION, res->type());
 
     const StunAddressAttribute* src_addr =
@@ skipping 18 matching lines @@
   Bind();
 
   // Wait twice the lifetime to make sure the server has expired the binding.
   rtc::Thread::Current()->ProcessMessages((LIFETIME * 2) * 1000);
 
   std::unique_ptr<StunMessage> req(CreateStunMessage(STUN_SEND_REQUEST)), res;
   AddMagicCookieAttr(req.get());
   AddUsernameAttr(req.get(), username_);
   AddDestinationAttr(req.get(), client2_addr);
 
-  StunByteStringAttribute* data_attr =
-      StunAttribute::CreateByteString(STUN_ATTR_DATA);
+  auto data_attr = StunAttribute::CreateByteString(STUN_ATTR_DATA);
   data_attr->CopyBytes(msg1);
-  req->AddAttribute(data_attr);
+  req->AddAttribute(std::move(data_attr));
 
   Send1(req.get());
   res.reset(Receive1());
 
   ASSERT_TRUE(res.get() != NULL);
   EXPECT_EQ(STUN_SEND_ERROR_RESPONSE, res->type());
 
   const StunErrorCodeAttribute* err = res->GetErrorCode();
   ASSERT_TRUE(err != NULL);
   EXPECT_EQ(6, err->eclass());
   EXPECT_EQ(0, err->number());
   EXPECT_EQ("Operation Not Supported", err->reason());
 
   // Also verify that traffic from the external client is ignored.
   SendRaw2(msg2, static_cast<int>(strlen(msg2)));
   EXPECT_TRUE(ReceiveRaw1().empty());
 }